python三个基本数字类型_Python3 基本数据类型

Python中的变量不需要声明，每个变量使用前必须赋值，变量赋值后才会被创建，在Python中变量就是变量，它没有类型。我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值，等号（=）运算符左边是变量名，等号（=）运算符右边是存储在变量名中的值。例如：

integer = 100 #这是整数，整型变量

float = 100.0 #这是浮点数，浮点型变量

string = "这是字符串" #这是字符串，字符串变量

print(integer)print(float)print(string)

执行以上程序会输出以下结果：

100

100.0这是字符串

多个变量赋值

Python中允许你同时为多个变量赋值。例如：

a=b=c=1

print(a)print(b)print(c)

执行以上程序会输出如下结果：

1

1

1

以上实例，创建一个整型对象，值为1，三个变量a,b,c被分配到相同的内存空间上。

也可以为多个对象指定多个变量。例如

a,b,c=1,2,3

print(a)print(b)print(c)

执行以上程序会输出如下结果：

1

2

3

以上实例，三个对象1,2,3分别分配给三个变量a,b,c。

标准数据类型

Python中有六个标准数据类型：

Number(数字)

String（字符串）

List(列表)

Tuple(元组)

Sets(集合)

Dictionary（字典）

Python的内置的type()函数可以用来查询变量所指的对象类型。例如

integer = 100float= 100.0string= "这是字符串"

print(type(integer)) #整型变量

print(type(float)) #浮点型变量

print(type(string)) #字符串变量

执行以上程序会输出如下结果：

Number(数字)

在Python3中支持int，float，bool，complex（复数）。像大多数语言一样，数值类型的赋值和计算都是很直观的。

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

print(100+False) #False代表数字0

print(100+True) #True代表数字1

执行以上程序会输出如下结果：

101

100

Python 支持三种不同的数值类型：

整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

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

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： + , - , * , / , // , ** 。

并且，不同类型的数值在进行混合运算时，会将整数转换成浮点数进行运算。

举例如下：

print(1+2) #加法

print(2-1) #减法

print(2*3) #乘法

print(10/5) #除法，得到浮点类型结果

print(21//5) #整数除法返回向下取整后的结果

print(21%5) #返回除法的余数

print(2**3) #幂运算，即2的三次方

print(2*3.0) #不同类型的数值在进行混合运算时，会将整数转换成浮点数进行运算

执行以上程序会输出如下结果：

3

1

6

2.0

4

1

8

6.0

String（字符串）

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

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

var1 = 'Hello World!'var2= "I don't know this person"

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值,-1 为末尾字符。从头下标（包括索引值为头下标的字符）开始截取到尾下标（不包括索引值为尾下标的字符）。例如：

var = 'abcdefghijklnm'

print (var) #输出字符串

print (var[4]) #输出字符串第五个字符

print (var[-1]) #输出最后一个字符

print (var[-2]) #输出倒数第二个字符

print (var[0:-1]) #输出第一个到最后一个（不包括最后一个）的所有字符

print (var[:4]) #输出字符串第五个字符之前的所有字符

print (var[2:5]) #输出从第三个开始到第五个（不包括第五个）的字符

print (var[2:]) #输出从第三个开始的后的所有字符

print (var * 2) #输出字符串两次

print (var + "TEST") #连接字符串

执行以上程序会输出如下结果：

abcdefghijklnm

e

m

n

abcdefghijkln

abcd

cde

cdefghijklnm

abcdefghijklnmabcdefghijklnm

abcdefghijklnmTEST

Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。例如：

print ("abcd\

efg") #\ (在行尾时)续行符

#输出结果：abcdefg

print("abcdef\\g") #\\ 反斜杠符号 == "\"

#输出结果：abcdef\g

print("abcde\'f\'g") #\' 单引号

#输出结果： abcde'f'g

print("abcde\"f\"g") #\" 双引号

#输出结果： abcde"f"g

print("abcdef\bg") #\b 退格，删除\b的前一个字符

#输出结果：abcdeg

print("abcdef\000g") #\000 空#输出结果：abcdef g

print("abcdef\ng") #\n

#换行 输出结果：abcdef#g

print("abcdef\tg") #\t 横向制表符

#输出结果：abcdef g

print(r"abcde\n\t\''\"") #字符串前面添加一个 r，表示原始字符串

#输出结果：abcde\n\t\''\"

关于Python字符串运算符：

var1="hello"var2="python"

print("var1+var2的输出结果为:",var1+var2) #+ 字符串连接

print(var1*2) #* 重复输出字符串

print(var1[1]) #[] 通过索引获取字符串中字符

print(var1[1:3]) #[a:b] 截取字符串中的一部分

if "h" in var1 : #in 成员运算符 - 如果字符串中包含给定的字符返回 True

print("h 存在变量var1中")else:print("h 不存在变量var1中")if "o" not in var1 : #not in 成员运算符 - 如果字符串中不包含给定的字符返回 True

print("o 不存在变量var1中")else:print("o 存在变量var1中")

执行以上程序会输出如下结果：

var1+var2的输出结果为: hellopython

hellohello

e

el

h 存在变量var1中

o 存在变量var1中

List(列表)

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

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

和字符串一样，列表也可以被索引和截取，第一个元素索引为0，第二个元素索引为1，一次类推。列表被截取后返回一个包含所需元素的新列表。

列表是写在方括号[]之间，用逗号分隔开的元素列表。创建一个列表，只要把逗号分隔开的数据用方括号括起来即可，例如：

list1=["first",1000,"a",5000]

list2=[1,2,3,4,5,6,7,8,9,10]

创建列表list1=["a","b","c","d","e","f","g","h","i","j","k","l","m","n"]

创建列表list2=[9,2,5,1,3,6,7,8,4]

列表的主要操作如下：

list1.append("this is append")#append 在列表最后一个元素的后面 添加一个元素

print(list1)#运行结果 ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","this is append"]

list1.insert(2,"b-c")#insert 第一个：要添加到位置索引，第二个：要添加的元素内容，添加内容到指定的索引位置

print(list1)#运行结果：["a","b","b-c","c","d","e","f","g","h","i","j","k","l","m","n"]

list2=["this is extend1","this is extend2"]

list1.extend(list2)#extend 将列表list2直接扩展到列表list1中#运行结果：list1.insert(2,"b-c")# insert 第一个：要添加到位置索引，第二个：要添加的元素内容，添加内容到指定的索引位置

print(list1)#运行结果：["a","b","b-c","c","d","e","f","g","h","i","j","k","l","m","n","this is extend1","this is extend2"]

list1.remove("a")#remove 已知元素内容，根据元素内容进行删除

print(list1)#运行结果：["b","c","d","e","f","g","h","i","j","k","l","m","n"]

var=list1.pop(0)#pop 会返回要删除的元素内容，已知元素索引，根据元素索引进行删除

print(var)print(list1)#运行结果a#运行结果["b","c","d","e","f","g","h","i","j","k","l","m","n"]

del list1[0] #del 已知元素索引，根据元素索引进行删除

print(list1)#运行结果["b","c","d","e","f","g","h","i","j","k","l","m","n"]

del list1 #从内存中删除list1列表

list1.clear() #清空列表元素

list1[0]="aa" #根据元素索引更改变元素内容更新列表

print(list1)#运行结果：["aa","b","c","d","e","f","g","h","i","j","k","l","m","n"]

list1[1:5]=["bb","cc","dd","ee"]#根据切片找到要修改的元素，更新列表

print(list1)#运行结果：["a","bb","cc","dd","ee","f","g","h","i","j","k","l","m","n"]

list2.reverse()#reverse 对列表元素进行倒序

print(list2)#运行结果：[4, 8, 7, 6, 3, 1, 5, 2, 9]

list2.sort()#sort 按照大小顺序对列表进行排序更新（从小到大）

print(list2)#运行结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

Tuple(元组)

Python 的元组与列表类似，不同之处在于元组的元素不能修改，不能更新，不能删除。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组中只包含一个元素时，需要在元素后面添加逗号。

元组与字符串类似，下标索引从0开始，可以进行截取、组合等。截取、组合的方法与list(列表)的方法一致。

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

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

键(key)必须使用不可变类型。

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

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示:

dic0 = {"key1" : "value1", "key2" :"value2"}

dic1={0:"a",1:"b",2:"c"}

dic={"name":"xiaoming","age":22,"sex":"man","hobby":["羽毛球","乒乓球","足球"]}

字典的操作方法主要有以下几种：

dic={"name":"xiaoming","age":22,"sex":"man","hobby":["羽毛球","乒乓球","足球"]}print(dic["name"])#读取字典中某个内容可以根据 [key(键)] 来进行查找，而不再是根据list中的索引#运行结果：xiaoming

print(dic.get("name")) #.get("key") 也可以进行读取#运行结果：xiaoming

for i in dic: #直接for遍历字典，会取到字典中的所有(key)键

print(i,end="\t")#运行结果：sex hobby name age

print(dic.keys()) #.keys 将字典中的所有（key）键 以dict_keys的类型进行返回 可进行列表转换#运行结果：dict_keys(['name', 'hobby', 'sex', 'age'])

print( dic.values()) #.values 将字典中的所有（values）值 以dict_values的类型进行返回 可进行列表转换#运行结果：dict_values(['xiaoming', 22, 'man', ['羽毛球', '乒乓球', '足球']])

print(list(dic.keys())) #list(dic.keys) 将dict_keys类型转换成list类型进行使用#运行结果：['name', 'hobby', 'sex', 'age']

print(dic.items()) #.items() 将字典的每个键值对以dict_items返回#运行结果：dict_items([('hobby', ['羽毛球', '乒乓球', '足球']), ('name', 'xiaoming'), ('sex', 'man'), ('age', 22)])

dic["name2"]="xiaohong" #直接根据 key(键) 赋值，如果存在这个（key）键 则对它进行更新 否则则添加该键值对

print(dic) #运行结果：{'name': 'xiaoming', 'hobby': ['羽毛球', '乒乓球', '足球'], 'name2': 'xiaohong', 'sex': 'man', 'age': 22}

dic.setdefault("name3","xiaoli")#.setdefault (key)键存在，不改动，返回字典中相对应的值(value)，(key)键不存在，在字典里增加新的 键值对，并返回相应的(value)值

print(dic)#运行结果：{'name3': 'xiaoli', 'hobby': ['羽毛球', '乒乓球', '足球'], 'age': 22, 'sex': 'man', 'name': 'xiaoming'}

dic.setdefault("name3","aaaaaaaax")print(dic)#运行结果：{'name3': 'xiaoli', 'sex': 'man', 'hobby': ['羽毛球', '乒乓球', '足球'], 'name': 'xiaoming', 'age': 22}

var=dic.pop("name")#.pop 根据（key）键 删除 键值对 并且返回所删除的值（value）

print(var) #运行结果：xiaoming

print(dic) #运行结果：{'hobby': ['羽毛球', '乒乓球', '足球'], 'age': 22, 'sex': 'man'}

del dic["name"]#del 根据（key）键 删除 键值对

print(dic)#运行结果{'sex': 'man', 'hobby': ['羽毛球', '乒乓球', '足球'], 'age': 22}

dic.clear()#清空字典

del dic #从内存中删除整个字典

dic2={"name22":"xiaohong",}

dic.update(dic2)#update dic2中的 键值对 如果在dic中存在，则进行修改更新，如果不存在 则进行添加

print(dic)#运行结果：{'sex': 'man', 'name22': 'xiaohong', 'age': 22, 'name': 'xiaoming', 'hobby': ['羽毛球', '乒乓球', '足球']}

print(sorted(dic))#对（key）键进行排序#运行结果：['age', 'hobby', 'name', 'sex']

print(sorted(dic.items()))#对键值对进行排序#运行结果：[('age', 22), ('hobby', ['羽毛球', '乒乓球', '足球']), ('name', 'xiaoming'), ('sex', 'man')]