Python基础—基本数据类型

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/li_jeremy/article/details/79604894

Python中不需要声明变量类型，每个变量在使用前必须赋值，在变量赋值后变量才会被创建。
在Python中，变量就是变量，没有类型
“=”左边用来放变量名，右边用来放所赋的值

#!/usr/bin/python3

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

多个变量赋值
允许同时为多个变量赋值

a=b=c=1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 “runoob” 分配给变量 c。

标准数据类型

有六个标准数据类型：

1. Number（数字）
2. String（字符串）
3. List（列表）
4. Tuple（元组）
5. Sets（集合）
6. Dictionary（字典）

Number（数字）
Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。

 a, b, c, d = 20, 5.5, True, 4+3j
 print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

还可以用instance来判断：

a = 111
isinstance(a, int)
True

isinstance和type的区别：

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

区别就是：

• type（）不会认为子类是一种父类类型
• isinstance（）会认为。。。

注：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
当指定一个值时，Number对象就会被创建：

a=1
b=2

可以通过del语句删除单个或多个对象。

del var1[,var2[,var3]]

还可以进行加减乘除运算

5+4 
4.3 - 2
3*7
2/4 #除法，得到一个浮点数
2//4 #除法，得到一个整数
17%3 #取余
2**5 # 乘方

注：

• Python可同时为多个变量赋值，a,b=1,2。
• 一个变量可以通过赋值指向不同类型的对象。
• 数值的除法（/）总是返回一个浮点数，获取整数要使用//
• 混合计算时，把整数转换成浮点数
  数值类型实例
  

String
字符串用单引号（”）或者双引号（“”）括起来，同时使用你反斜杠（\）转义特殊字符。
字符串截取语法

变量[头下标:尾下标]

索引值以0为开始值，-1为从末尾的开始位置。
加号（+）是字符串的连接符，星号（*）表示复制当前字符串，紧跟的数字为复制的次数。

!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 连接字符串

Python使用反斜杠（\）进行转义，如果不想转义，在字符之前加一个r，表示原始字符串:

print'ru\noob')
ru
oob
print(r'ru\noob')
ru\noob

另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”“…”“” 或者 ”’…”’ 跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

word = 'Python'
print(word[0],word[5])
P n
print(word[-1],word[-6])
n P

在Python中字符串不能 被改变，想一个位置进行赋值的话，会导致错误
注：

• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义
• 字符串可以用+运算符连接在一起，用*表示重复。
• Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
• 字符串不能改变

List
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表可以被索引和截取，列表被截取后返回一个包含所需元素的额新列表。
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

#!/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 (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

列表中的元素可以改变
注：

• List写在方括号中，元素用逗号隔开
• list可以被索引和切片
• 可以使用+进行拼接
• 元素可以被改变

Tuple
其与列表的不同之处在于元组不可以被改变，其实一种特殊的列表，其写在()小括号里，元素之间用逗号隔开，元组中的元素类型也可以不尽相同：

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。
其实，可以把字符串看作一种特殊的元组。

>>>tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

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

• 与字符串相同，元组的元素不能被修改
• 也可以被索引和切片，方法一样
• 注意
• 元组的元素不能被改变
• 元组也可以被索引和切片，方法一样
• 构造包含0或1个元素的元组的特殊语法
• 元组也可以使用+操作符进行拼接

Set（集合）
无序不重复元素列表。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号{}或者set()函数创建集合，注意：创建一个空的集合必须用set()而不是{}，因为{}是用来创建一个空字典。
创建格式：

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

!/usr/bin/python3

student = {‘Tom’, ‘Jim’, ‘Mary’, ‘Tom’, ‘Jack’, ‘Rose’}

print(student) # 输出集合，重复的元素被自动去掉

成员测试

if(‘Rose’ in student) :
print(‘Rose 在集合中’)
else :
print(‘Rose 不在集合中’)

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b)     # a和b的差集

print(a | b)     # a和b的并集

print(a & b)     # a和b的交集

print(a ^ b)     # a和b中不同时存在的元素

输出如下:

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

Dictionary(字典)
列表是有序地对象集合，字典是无序的对象集合。两者之间的区在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用{}标识，它是一个无序的键（key）：值（value）对集合
键必使用不可变的类型
在同一个字典中，键必须是唯一的。

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}


print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出如下:

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])

构造函数dict()可以直接从键值对序列中构建字典如下:

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(Runoob=1, Google=2, Taobao=3)
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

注：

• 字典是一种映射类型，它的 元素是键值对
• 字典的关键字必须为不可变类型，且不能重复
• 创建空字典必须使用{}
  Python数据类型转换
  有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
  以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。