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

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

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

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

  一、数字(Number)类型

  python中数字有四种类型：整数、布尔型、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数), 如 1 + 2j、 1.1 + 2.2j

tmp_int = 1
print(type(tmp_int))
tmp_float = 10.0
print(type(tmp_float))
tmp_bool = True
print(type(tmp_bool))

二、字符串(String)

• Python 中单引号 ‘ 和双引号 “ 使用完全相同。
• 使用三引号(‘’’ 或 “””)可以指定一个多行字符串。
• 转义符 \。
• 反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示，并不是换行。
• 按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python 中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

str = 'runoob'
print(type(str))
print(str)  # 输出字符串
print(str[0:-1])  # 输出第一个字符串到倒数第二个的所有的字符
print(str[0])  # 输出字符串第一个字符
print(str[2:5])  # 输出第三个字符到第五个字符
print(str[2:])  # 输输出从第三个开始的后的所有字符
print(str * 2)  # 输出字符串两次
print(str + "test")  # 字符串拼接
print("我叫 %s" % ("小明")) #字符串格式化

1.f-string格式化用法

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下

x= 1
print(f'{x + 1=}')
w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f'{w["name"]}: {w["url"]}')
name = 'Alex'
age = 20
print(f'我叫 {name},我今年{age}岁')

2. 常见的内置函数

# 一、str 转化为bytes类型，bytes类型转化为str
# encode()
print(s)
# 以Unicode表示的str通过encode()方法可以编码为指定的bytes
b = s.encode(encoding='utf-8')
print(b)
c = b.decode(encoding='utf-8')
print('c的值为', c)  # bytes 转化为str
print('c的类型是:', type(c))

3.字符串中的运算符

三、List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：

变量[头下标:尾下标]

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

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
typelist = [True, 'alex']
print(list)  # 打印出list 列表
print(list[0])  # 打印出list列表的第一个元素
print(list[1:3])  # 打印出list 第二个元素到第三个元素 左闭右开
print(list[2:])  # 输出第二个元素到最后的元素
print(list * 2)  # 输出两次
print(list + typelist)  # 列表拼接

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
print(list[-2])  # 打印出list 倒数第二个元素
print(list[:-2])  # 打印出从第一个元素到倒数第二个元素
print(list[0:-2])  # 打印出第一个元素到倒数第二个元素 0 可以省略
print(list[1:-2])  # 打印出list第二个元素到倒数第二个元素

1. 列表比较

import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print('operator.eq(a, b)', operator.eq(a, b))
print('operator.eq(a, b)', operator.eq(b, c))

2.list中的内置函数

| list.append(obj)

在列表末尾添加新的对象 | | | —- | —- | | 2 | list.count(obj)

统计某个元素在列表中出现的次数 | | 3 | list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） | | 4 | list.index(obj)

从列表中找出某个值第一个匹配项的索引位置 | | 5 | list.insert(index, obj)

将对象插入列表 | | 6 | list.pop([index=-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 | | 7 | list.remove(obj)

移除列表中某个值的第一个匹配项 | | 8 | list.reverse()

反向列表中元素 | | 9 | list.sort( key=None, reverse=False)

对原列表进行排序 | | 10 | list.clear()

清空列表 | | 11 | list.copy()

复制列表 |

#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (list[-2])        # 输出倒数第二个元素，一般只要有负数都是倒数
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表
# 列表中函数和方法
print('list长度为：', len(list))
print('list中的最大值', max(list))
print('list中的最小值', min(list))
# list 的操作 ，增加，修改，删除
list.append("alex")
print('list元素增加之后:', list)
print('统计list中某个元素出现的次数：', list.count(list[0]))
print('在列表中找出某一个值的匹配的索引值', list.index(list[0]))
list.insert(0, 'aaa')
print('插入一个元素', list)
list.reverse()
print('反向输出列表', list)
list.remove(list[0])
print('list列表删除首元素之后', list)
tmp = list.copy()
print('copy list ', tmp)
list.clear()
print('清除list中的元素之后: ', list)
print([1, 2, 3] + [4, 5, 6])

3.切片

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 切片
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
#  1、切片取单个元素：
print(L[0])
# 取值
print('L[1:3] =', L[1:3])
# 取值，取最后两个元素
print('L[-2:] =', L[-2:])
# 取值，取最后一个元素
print('L[-1]=', L[-1])
# 2、取完整对象
print(L[:]) #从左往右
print(L[::])#从左往右
print(L[::-1])#从右往左
# 3. start_index和end_index全为正（+）索引的情况
# 取值，,从0到3，取前N个元素，也就是索引为0-(N-1)的元素，可以用循环
print('L[0:3] =', L[0:3])
# 取值前3个元素
print('L[:3] =', L[:3])

4.遍历list的两种方式

# 遍历list 并且输出索引和值
list = [1,213,3,4,5,6]
for index,element in enumerate(list):
    print(index,element)
# 遍历list，输出里面的元素
for i in list:
    print(i)
# 按照索引遍历list
for j in range(len(list)):
    print(list[j])

四、Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：
atuple = tuple()
atuple= ('Mic','Ca','As')
print(atuple)
# 取值
print(atuple[0])  # 取第一个元素
print(atuple[-1]) # 取最后一个元素
print(atuple[1:]) # 取从第二个元素到最后
print(atuple[:-1]) # 从第一个元素 到最后第一个元素
print(atuple[len(atuple)-1])
classmates = ('Michael', 'Bob', 'Tracy')
print('classmates =', classmates)
print('len(classmates) =', len(classmates))
print('classmates[0] =', classmates[0])
print('classmates[1] =', classmates[1])
print('classmates[2] =', classmates[2])
print('classmates[-1] =', classmates[-1])
# cannot modify tuple: 元祖不能赋值
classmates[0] = 'Adam'

五、Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1.常见用法：

创建格式：

parame = {value01,value02,…} 或者 set(value)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
s1 = set([1, 1, 2, 2, 3, 3])
print(s1)
s2 = set([2, 3, 4])
print(s1 & s2)
print(s1 | s2)
# set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
# 针对自动重复的值，进行了自动过滤,set 还对他默认进行了排序
s = set([9, 3, 4, 5, 6, 7, 8, 1])
print(s)
s.add(2) # set 添加元素 
s.remove(2) # set 移除元素
print(s)
s5 = set(['a', 'd', 'c'])
print(s5)

2.

六、Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型字典是另一种可变容器模型，且可存储任意类型对象。字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。

1. 字典的常用用法

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

tmp_dict = dict()
print(tmp_dict)
print('长度是：', len(tmp_dict))
print('类型是:', type(tmp_dict))
# 给字典中追加元素
tmp_dict['name'] = 'alex'
tmp_dict['age'] = 28
tmp_dict['sex'] = 'man'
del tmp_dict['name'] #删除字典中的键值name
print(tmp_dict)
print(tmp_dict.keys())  # 打印所有的keys
print(tmp_dict.values())  # 打印所有的value
# tmp_dict.clear() 清除字典中的所有元素
# del tmp_dict  删除字典
# 遍历字典的方法：
# 方法一：遍历key，取到value
for k in tmp_dict.keys():
    print(k, ':', tmp_dict.get(k))
# 方法二：遍历value 值
for v in tmp_dict.values():
    print(v)
# 方法三：直接遍历出key 和value值
for (k, v) in tmp_dict.items():
    print(k, v)

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

2.字典常见的内置函数

删除字典内所有元素 | | 2 | dict.copy()

返回一个字典的浅复制 | | 3 | dict.fromkeys()

创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 | | 4 | dict.get(key, default=None)

返回指定键的值，如果键不在字典中返回 default 设置的默认值 | | 5 | key in dict

如果键在字典dict里返回true，否则返回false | | 6 | dict.items()

以列表返回一个视图对象 | | 7 | dict.keys()

返回一个视图对象 | | 8 | dict.setdefault(key, default=None)

和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default | | 9 | dict.update(dict2)

把字典dict2的键/值对更新到dict里 | | 10 | dict.values()

返回一个视图对象 | | 11 | pop(key[,default])

删除字典 key（键）所对应的值，返回被删除的值。 | | 12 | popitem()

返回并删除字典中的最后一对键和值。 |