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 = 100
float   = 100.0
string  = "这是字符串"

print(type(integer))    #整型变量
print(type(float))      #浮点型变量
print(type(string))     #字符串变量

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

<class 'int'>
<class 'float'>
<class 'str'>

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 10² = 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')]