Python的数据类型

标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）分别包括： 
  • int、
  • float
  • bool
  • complex（复数）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

string、list 和 tuple 都属于 sequence（序列）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number、String、Tuple；
• 可变数据（3 个）：List、Dictionary、Set。

# 各类型的定义格式
deposit = 0
salary = 23.55
name = 'xiyang'
house = ['天津','河北']
family = ('老妈','老爸','老公','老弟') # 不可变
job = {'work':'软件测试','time':'早9晚6'}
age = set('18') # 不可重复
print(type(deposit),type(salary),type(name),type(house),type(family),type(job),type(age))
# <class 'int'> <class 'float'> <class 'str'> <class 'list'> <class 'tuple'> <class 'dict'> <class 'set'>

#追加格式
house.append('北京')
job.setdefault('price',22.33)
age.add(20)
print(house,job,age)

int（整型）

简介：

通常被称为整型或整数，是正或负整数，不带小数点。python3中整型是没有限制大小的，可以当做Long类型使用，所有python3中没有Long类型

语法：

age = 18
num = -22
a,b,c = 0,1,2# 一次给多个变量赋值

print(age)
print(num)
print(a,b,c)

float（浮点型）

简介：

 浮点类型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 *10次方 = 250 ），浮点型也就是带有小数点的数，其精度和机器有关。

语法：

score = 82.342
num = -022.1

print(score)
print(num)

complex（复数）

简介：

 Python还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

语法：

pass

boole（布尔类型）

简介：

在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）

语法：

age = 18


print(age > 19)
print(age < 19)

#>>>False
#>>>True

string（字符串类型）

简介：

字符串是 Python 中最常用的数据类型。我们可以使用引号( '' 或 "" )来创建字符串。

Python中的字符串有两种数据类型，分别是str类型和unicode类型，str类型采用的ASCII编码，无法表示中文，unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。

创建字符串很简单，只要为变量分配一个值即可。

实例：

字符串定义

var1='xiyang'
addr = '北京'

字符串更新

var2='Hello xiyang'

# 截取字符串的一部分并与其他字段拼接
print('已更新的字符串：',var2[:6]+'python')
print('已更新的字符串：','Hi'+var2[-7:])

字符串常用方法：

查找

# Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
# Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下

var1 = 'Hello World!'
var2 = "Python"

print(var1[0]) # 打印字符串var1中下标为0的元素
print(var2[1:5]) # 打印字符串var2中下标从1-5的元素（前包后不包）
print(str.index('x')) # 根据元素查找下标。如果下标不存在，报错ValueError: substring not found。不推荐使用

str = 'Hi xiyang'

print(str.find('x')) # 根据元素查找下标。如果下标不存在，返回-1。推荐使用
print(str.count('i')) # 统计字符串中某个出现的次数

 去空格

s = '   a  bc    '

print(s.strip()) # 去掉字符串两边的空格和换行符
print(s.rstrip())# 只去掉右边的空格和换行符
print(s.lstrip()) # 只去掉左边的空格和换行符
print(s.replace('a','A')) # 替换，将前边的替换为后边的
print(s.replace(' ','')) # # 去中间空格，该方法可以替换中间的空格，将空格替换为空

大小写转换

s1 = 'Python'

print(s1.upper())# 把所有的字母都变成大写
print(s1.lower())# 把所有的字母都变成小写
print(s1.capitalize())# 把首字符变为大写
print(s1.center(50,'*'))# 设置等长为50，若不足50用指定字符在两边填充

判断字符格式

s2 = 'A!TD22. 3'

print(s2.isupper())# 出现的字母，是不是都是大写字母
print(s2.islower())# 出现的字母，是不是都是小写字母
print(s2.isalpha())# 是字母或汉字，返回True
print(s3.isalnum())# 只有数字或者字母或汉字会返回True，其他的都返回False

判断是否是整数

s4 = '123'

print(s.isdigit())# s = '-1's中不只有整数，还有符号-，所以返回False
print(s4.isdigit())# s2 = '0's2中是整数，所以返回True
print(s4.zfill(5))# 前面补0，这里设置的5为补0后的总长度（该方法仅支持字符串类型）

判断是否以指定字符开头或结尾。返回布尔值True和False

print(s1.startswith('a')) # 判断开头
print(s1.endswith('.jpg')) # 判断结尾

分割（拆分）字符串 split

str = 'hello 
python 
hi'

print(str.split(' ')) # 以空格分隔，包含

#>>>输出结果：['hello', '
python', '
hi']

print(str.split(' ',1)) # 以第一个空格分隔，分隔为两个
#>>>输出结果：['hello', '
python 
hi']

str = 'my..name..is..xiyang'
print(str.split('..'))# 使用..拆分 ['my', 'name', 'is', 'xiyang']
print(str.split('..',-1))# 等价于str.split ['my', 'name', 'is', 'xiyang']
print(str.split('..',0))# 和没拆分一样 ['my..name..is..xiyang']
print(str.split('..',1))# 以第一个..拆分，拆分为两个 ['my', 'name..is..xiyang']
print(str.split('..',2))# 以第一个..拆分，拆分为三个 ['my', 'name', 'is..xiyang'

连接字符串 join（和split效果相反）

str1 = ['my', 'name', 'is', 'xiyang']
print(' '.join(str1)) # 将str1中的list使用空格连接
print('_'.join(str1)) # 将str1中的list使用下划线连接
print(''.join(str1)) # 将str1中的list使用空连接，也就是将连接符都去掉

字符串格式化：%s、%d、%f

# 占位符：%s ，是万能占位符，可以跟字符串、整数、小数。如：'欢迎【%s】登录，今天的日期是:%s'
# 占位符：%d ，代表整数占位符。如：'你的年龄是：%d'。如果是%d，后边一定是要跟int类型，因为input接收的都是字符串类型，所以要在input时转换成int类型
# 占位符：%f ，代表小数占位符。如：'你的成绩是：%.2f' 。如果是%f，后边一要跟float类型，float默认保留小数点后6位，如果想保留2位则写为：%.2f，想保留几位就写%.xf
# 只有一个变量的写法
for i in range(3):
    username = input('请输入你的名字：')
    welcome = '欢迎【%s】登录' % username
    # welcome2 = '欢迎'+username+'登录'# 简单粗暴的方式，用+号连接，不推荐
    print(welcome)

    age = int(input('请输入你的年龄：'))
    a1 = '你的年龄是：%d' % age
    print(a1)

    score = float(input('请输入你的成绩：'))
    s1 = '你的成绩是：%.2f' % score
    print(s1)


print('==================开始多个变量的写法===================')
# 多个变量的写法
import datetime # 导入datetime包
today = datetime.datetime.today()# 获取当前日期
for i in range(3):
    username = input('请输入你的名字：')
    age = int(input('请输入你的年龄：'))
    score = float(input('请输入你的成绩：'))
    welcome = '欢迎【%s】登录，今天的日期是：%s，你的年龄是：%d，你的成绩是：%.2f' % (username,today,age,score)# 如果是多个%s，后面就要跟多个变量，多个变量要使用括号括起来
    # welcome2 = '欢迎' + username + '登录,'+'今天的日期是：' + str(today)# 字符串拼接的方式，需要是相同类型，所以需要将today转换为字符串格式。用+号连接，不推荐
    print(welcome)

 字符串格式化：format、format_map

# format方法和format_map方法是做字符串格式化的，用{}占位，区别在于format_map方法传的是字典格式。同%s，两种都是做字符串格式化，用哪个都可以，数据多的时候推荐用该方法
s5 = '今天是{},欢迎{}登录'
print(s5.format('2020-04-08','xiyang'))
# 举例
s6 = 'insert into stu(id,name,email,phone,addr) value({id},{name},{email},{phone},{addr})'
# .format{}方法，直接在可变的值中定义好名字，传值时不需要按顺序传值，也可以正确插入
print(s6.format(phone = '17611111111',name = 'xiyang',id = 1,email = '1366625010@qq.com',addr = '北京市'))
# .format_map
print(s6.format_map({'phone':'17611111111','name':'xiyang','id':1,'email':'1366625010@qq.com','addr':'北京市'}))


# 演示三种写法（%s、format、format_map）的区别
s6 = 'insert into stu(id,name,email,phone,addr) value({id},{name},{email},{phone},{addr})'
id = input('请输入id：')
name = input('请输入name：')
phone = input('请输入phone：')
addr = input('请输入addr：')
email = input('请输入email：')

#  %s方式
print('insert into stu(id,name,email,phone,addr) value(%s,%s,%s,%s,%s)' % (phone,id,addr,name,email))
#  format方式
print(s.format(phone=phone,addr=addr,id=id,name=name,email=email))
#  format_map方式
print(s.format_map({'phone':phone,'name':name,'id':id,'email':email,'addr':addr}))
#  结论：%s的方式，当数据多时，如果顺序传混了，那么存值也就存混了，如id在前方，我传了phone在前方，系统就会把我输入的phone的值，放到id中

list（列表、数组）

简介：

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中可以放任何数据类型，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

可对列表进行创建、查找、切片、增加、修改、删除、循环和排序操作。

索引值以 0 为开始值，-1 为从末尾的开始位置。

语法格式：

list = [元素1,元素2,元素...] # 字符串类型的需要用引号括起来，数字类型的则不用

实例：

创建

list = [123,1.56,'python','java','!@#']
list = [] # 创建一个空列表

查询

print(list) # 输出完整的列表，即[123, 1.56, 'python','java','!@#']
print(list[0]) # 输出第一个元素，即123
print(list[1:4]) # 输出从第二个元素开始，到第四个元素，即[1.56, 'python', 'java']
print(list[2:]) # 输出从第三个元素（第二个下标）开始的所有元素，即['python','java','!@#']
print(list[:-3]) # 输出倒数第三个元素之前的所有元素，即[123, 1.56]
print(list * 2) # 输出两次列表，即[123, 1.56, 'python','java','!@#', 123, 1.56, 'python','java','!@#']

新增

mobile = ['oppo','小米','三星','vivo']
mobile.append('华为') # append方法是在列表的末尾增加一个元素
print(mobile)

mobile.insert(1,'一加') # insert方法是在列表的指定位置增加一个元素
print(mobile)

修改

mobile[1] = '苹果'
print(mobile)

删除

mobile.pop(1) # pop和del方法是指定下标删除，下标不存在会报错
print(mobile)

del mobile[2]
print(mobile)

mobile.remove('小米') # remove方法是指定元素删除，元素不存在会报错
print(mobile)

列表常用方法

num = [33,1,3,45.67,99,1093,44,32,67,1]
num1 = [9,8,7]
print(num.count(1)) # 查找参数出现的次数
print(num.index(44)) # 查找元素的下标
print(len(num)) # 打印num数组中的元素个数
# print(num.clear()) # 清空列表

num.extend(num1) # 合并列表，合并后产生一个新列表
num2 = num + num1 # 用加号拼接列表，也可达到合并列表的目的

num.sort() # 排序，默认升序
num.sort(reverse=True) # 倒序排序
num.reverse() # 反转，即把最后一个展示在前面，前面的展示到最后，和排序是有区别的
print(num) # 您可能已经注意到，方法sort、reverse只修改列表，没有返回值，它们返回的默认 None。这是Python中所有可变数据结构的设计原则。所以如果直接使用print(num.sort)输出的是None

 多维数组 创建 & 取值

array = ['1','2','3','4',['a','b','c','d']] # 二维数组
array1 = [1,2,3,4,['A','B','C','D',['!','@','#','$']]] # 三维数组
array2 = [1,2,3,['A','B','C','D','E',['!','@','#','$',['2',3,'P','T']]]] # 四维数组


print(array1[4][4][1])# 取值@
print(array2[3][5][4][2])# 取值P

嵌套列表

arr1 = ['a','b','c','d']
arr2 = [1,2,3,4]
arr3 = ['你','好']

arr = [arr1,arr2,arr3]
print(arr)
# >>> [['a', 'b', 'c', 'd'], [1, 2, 3, 4], ['你', '好']]

tuple（元组）

简介：

元组与列表类似，不同之处在于元组的元素不能修改，所以不支持append、inster、pop等方法。

元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同。

注意构造包含 0 或 1 个元素的元组的特殊语法规则。

实例：

元组创建 & 查找

tuple = (1,1,2.53,'!@#','oppo','小米','三星','vivo')
tuple1 = ('苹果','华为')
tuple2 = () # 创建一个空元组
tuple3 = (20,) # 一个元素，需要在元素后面添加逗号

print(tuple) # 打印tuple元组
print(tuple[2]) # 打印出元组中下标为2的元素
print(tuple[:4]) # 打印元组中下标为4之前的所有元素（不包含下标4）
print(tuple[2:]) # 打印元组中从下标2开始，之后的所有元素（包含下标2）
print(tuple[3:6]) # 打印元组中从下标3开始（包含下标3），到下标6之前的元素（不包含下标6）
print(tuple * 2) # 输出两次元组
print(tuple + tuple1) # 合并元组，元组不支持extend的方式合并

print(tuple.index('oppo')) # 查找某个元素的下标
print(tuple.count(1)) # 统计某个元素出现的次数
print(len(tuple)) # 打印出元组中元素的个数

 多维元组 / 元组嵌套

tuple = (1,1,2.53,'!@#','oppo','小米','三星','vivo',('苹果','华为'),['锤子','一加'])
print(tuple[-3:])

# 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

dictionary（字典）

简介：

字典是一种键值对的集合，是Python中除列表以外，另一个非常有用和灵活的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

字典的key必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

实例：

创建

info1 = {} # 创建一个空字典


info2 = {
    'moble':'iphone 12 pro max'
}

info = {
    'name': '溪洋',
    'num':13412345678,
    'qq':1361111,
    'email':'1361111@qq.com',
    'addr':'北京'
} # 创建一个有内容的字典

 查询

print(info['name']) # 输出key为name的value,取不存在的key，会报错。不推荐使用
print(info.get('addr')) # 输出key为name的value,取不存在的key，返回None。推荐使用


print(info.keys()) # 输出字典中所有的key，注意字典是无序的
print(info.values()) # 输出字典中所有的value，注意字典是无序的

info.update(info2) # 合并字典
print(info) # 输出完整的字典

新增 

info.setdefault('sex','女') # 该写法如果新增的key在原列表中存在，对其不做处理
info ['age'] = 18 # 该写法如果新增的key在原列表中存在，会对原有值进行修改

修改

info ['num'] = '133' # 通过key修改value

删除

info.pop('email') # 删除指定key，和del的两种写法没区别
del info['num'] # 删除指定key，和pop的两种写法没区别
info.popitem() # 随机删除指定key，该功能基本用不到
# info.clear() # 清空字典
print(info)

常用方法

info = {
    'name': '溪洋',
    'num':13412345678,
    'qq':1361111,
    'email':'1361111@qq.com',
    'addr':'北京'
} # 创建一个有内容的字典

print(len(info)) # 计算字典元素个数，即键的总数。
print(type(info)) # 返回输入的变量类型，如果变量是字典就返回字典类型。
print('name' in info) # 判断键。如果键在字典dict里返回true，否则返回false

字典嵌套

info = {
    'xiyang':{
        'house':['北京','上海','成都','江苏'],
        'car':{
            'china':['比亚迪','长安','红旗'],
            'japan':['丰田','马自达','雷克萨斯'],
            'Genmany':{
                '奔驰':2,
                '宝马':3,
                '大众':5
            }
        }
    }
}

# 溪洋又买了一辆宝马
stu_info['xiyang']['car']['Genmany']['宝马']+=1 # a+=1等同于a=a+1。包括-= /= *=同理，如a-=2，就是a=a-2
print(stu_info)
# 溪洋把比亚迪扔掉了
stu_info['xiyang']['car']['china'].remove('比亚迪')# 按照字典层级去找
print(stu_info)

字典循环

# 第一种效率快一些，第二种慢一些，数据多的话用第一种

accounts = {
    'name':'xiyang',
    'age':18,
    'job':'软件测试'
}
accounts1 = {
    'sex':'女'
}
accounts2 = {
    'email':'136000',
　　 'sex':'女'


# 方法一：直接循环字典
for k in accounts: # 
    print('%s ==> %s' %(k,accounts[k]))


# 方法二：使用items()函数
for k,v in accounts.items():
    print('%s ==> %s' % (k,v))

# enumerate()函数：同时取位置索引和对应的值
for i, v in enumerate(accounts):
      print(i, v) # >>>0 name  1 age  2 job

# zip() 函数：同时循环两个或多个序列
for a,b,c in zip(accounts,accounts1,accounts2):
    print(accounts,accounts1,accounts2) # >>>{'name': 'xiyang', 'age': 18, 'job': '软件测试'} {'sex': '女'} {'email': '136000', 'sex': '女'}

# reversed()函数：逆向循环
for i in reversed(accounts):
    print(i,accounts[i])

json & pickle

简介

# 在python中，有专门处理json格式的模块--json 和 pickle模块
# json   模块提供了四个方法： dumps、dump、loads、load
# pickle 模块也提供了四个功能：dumps、dump、loads、load

# json的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。
# json的数据必须使用双引号

实例

import json
data = {
    "error_code":0,
    "stu_info":[
        {
            "id":300,
            "name":"怡宝",
            "sex":"男",
            "age":18,
            "addr":"北京市海淀区"
        },
        {
            "id": 301,
            "name": "农夫山泉",
            "sex": "女",
            "age": 18,
            "addr": "北京市朝阳区"
        },
        {
            "id": 302,
            "name": "百岁山",
            "sex": "男",
            "age": 18,
            "addr": "北京市昌平区"
        }
    ]
}

# json模块把字典转成json字符串的方法--dumps
with open('abc.txt','w',encoding='utf-8') as fw:
    s = json.dumps(data,ensure_ascii=False, indent=4) 
    fw.write(s)
    print(s)

# 参数解释：
# data，需要转换为json格式的字符串
# ensure_ascii=False，解决中文问题，若为True则输出的格式为Unicode
# indent=4，代表缩进，4个空格

# json模块把字典转成json字符串的方法--dump
with open('abc.txt','w',encoding='utf-8') as fw:
    s = json.dump(data,fw,ensure_ascii=False, indent=4) 
    print(s)

# 参数解释：
# data，需要转换为json格式的字符串（字典）
# fw, 需要打开的文件名
# ensure_ascii=False，解决中文问题，若为True则输出的格式为Unicode
# indent=4，代表缩进，4个空格

# dumps方法和dump方法的区别：
# dump比dumps方法多传一个文件名，dump就不需要手工的write一次了，这个方法会自动write。

# json模块把字符串转成字典的方法--loads
with open('abc.txt', encoding='utf-8') as fr:  # json字符串要在文件中存在才可以
    result = fr.read()
    print('result,刚从文件里面读出来的',result,type(result))

    dic = json.loads(result)  # loads代表字符串转成字典
    print('dic,转换完之后的', dic, type(dic))

# json模块把字符串转成字典的方法--loads
with open('abc.txt', encoding='utf-8') as fr:  # json字符串要在文件中存在才可以
    result = json.load(fr)
    print('result',type(result))
    print(result)

# loads方法和load方法的区别：
# load比loads方法多传一个文件名，load方法就不需要手工的read一次了，这个方法会自动read，相对来说load方法更简单一些

set（集合）

简介：

集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是：进行成员关系测试和删除重复元素。

集合是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合天生可以去重，并且是无序的（就是不能通过下标来取值）。但是可以通过循环去取值

 实例：

 定义&取值

s = set() # 定义一个空集合

s1 = [1,1,2,3,4,3]
print(set(s1))
# 输出的结果是{1, 2, 3, 4}

#通过循环取值
for i in s1:
    print(i)
# 输出的结果是1 1 2 3 4 3

添加元素 add()和update()

s = set() # 定义一个空集合

# add()方法添加元素：参数可以是整数，小数，字符串，元组
s.add(1) 
s.add(2.32)
s.add('d')
s.add((7,))
print(s)

# update()方法添加：参数可以是列表，元组，集合，字典，字符串

s.update([2])
s.update((5,))
s.update({3})
s.update({'name':'xiyang'}) # 只能将key添加进去'name'
s.update('2')
print(s)

# 使用add()和update()两种方法重复添加值

s2 = {8,9,10,11,'a'} # 如果添加重复的元素，比如s2.add(8)、s2.update('a')，是不会加进去的。因为集合本身就是不能重复的
s2.add(8)
s2.update('a')
s2.update(['a','b'])
print(s2) # >>>{'b', 8, 9, 10, 11, 'a'}只添加进去了b，因为a和8原本的集合中已经存在了

删除

s.remove(1) # 删除元素
s.discard(5) # 删除集合中指定的元素
print(s.pop()) # 随机删除一个元素

print(s)

其他

print(len(s2))# 打印集合中元素的长度（去重后的长度）
print(s.copy()) # 拷贝一个集合

 交集、并集、差集、对称差集

language1 = ['c','c++','java','python']
language2 = ['python','js','css','html']

lan1_set = set(language1)
lan2_set = set(language2)

# 取交集的两种写法。取多个集合里边都有的
print(lan1_set.intersection(lan2_set))
print(lan1_set & lan2_set)
# >>> {'python'}

# 取并集的两种写法。把多个集合合并到一起，在去重
print(lan1_set.union((lan2_set)))
print(lan1_set | lan2_set)
# >>> {'c', 'js', 'java', 'html', 'c++', 'python', 'css'}

# 取差集的两种写法。取出在a集合里边有，在b集合里边没有的
print(lan1_set.difference(lan2_set))
print(lan1_set - lan2_set)
# >>> {'java', 'c', 'c++'}

# 取对称差集的两种写法。把多个集合中都有的元素删除，在取出（两个集合的并集减去它们的交集）
print(lan1_set.symmetric_difference(lan2_set))
print(lan1_set ^ lan2_set)
# >>> {'c', 'js', 'java', 'html', 'c++', 'css'}

判断

language1 = ['c','c++','java','python']
language2 = ['python','js','css','html']

lan1_set = set(language1)
lan2_set = set(language2)
print(lan1_set.isdisjoint(lan2_set)) # 判断两个集合是否包含相同的元素，如果有返回 False，如果没有返回 True。
print(lan1_set.issubset(lan2_set)) # 判断指定集合是否为该方法参数集合的子集。如果有返回 True，如果没有返回 False。
print(lan1_set.issuperset(lan2_set)) # 判断该方法的参数集合是否为指定集合的子集。如果有返回 True，如果没有返回 False。