关于Python的变量类型

　　1. 变量

　　变量存储在内存中的值

　　这就意味着在创建变量时会在内存中开辟一个空间

　　基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中

　　因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符等

　　2. 赋值

　　Python 中的变量赋值不需要类型声明

　　每个变量在内存中创建，都包括变量的标识，名称和数据这些信息

　　每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

　　等号(=)用来给变量赋值

　　等号(=)运算符左边是一个变量名

　　等号(=)运算符右边是存储在变量中的值

　　counter = 100 # 赋值整型变量

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

　　a = b = c = 1

　　a, b, c = 1, 1.0, "1"

　　3. 标准

　　在内存中存储的数据可以有多种类型

　　例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储

　　Python 定义了一些标准类型，用于存储各种类型的数据。

　　Python有五个标准的数据类型

　　Numbers(数字)

　　数字数据类型用于存储数值

　　是不可改变的数据类型

　　这意味着改变数字数据类型会分配一个新的对象

　　当指定一个值时，Number对象就会被创建：

　　var1 = 1

　　也可以使用del语句删除一些对象的引用

　　del var1

　　支持三种不同的数字类型：

　　int(有符号整型)

　　float(浮点型)

　　complex(复数)

　　例如：

　　int　　float　　complex

　　10　　10.0　　(10+0j)

　　String(字符串)

　　字符串或串(String)是由数字、字母、下划线组成的一串字符

　　是编程语言中表示文本的数据类型

　　s = "a1a2···an" # (n>=0)

　　字串列表有2种取值顺序:

　　从左到右索引默认0开始的，最大范围是字符串长度少1

　　从右到左索引默认-1开始的，最大范围是字符串开头

　　s = 'joveH-H'

　　print(s) # 输出完整字符串

　　print(s[0]) # 输出字符串中的第一个字符

　　# joveH-H

　　# j

　　如果要实现从字符串中获取一段子字符串

　　可以使用 [头下标:尾下标] 来截取相应的字符串

　　其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾

　　获取的字符串包含头下标的字符，但不包含尾下标的字符

　　print(s[2:5]) # 输出字符串中第三个至第五个之间的字符串

　　print(s[2:]) # 输出从第三个字符开始的字符串

　　# veH

　　# veH-H

　　可以接收第三个参数，参数作用是截取的步长

　　以下实例在索引 2 到索引 5 的位置并设置为步长为 2(间隔一个位置)来截取字符串

　　print(s[2:5:2]) # 输出字符串中第三个至第五个之间间隔2的字符串

　　# vH

　　List(列表)

　　列表可以完成大多数集合类的数据结构实现

　　支持字符，数字，字符串甚至可以包含列表(即嵌套)

　　列表用 [ ] 标识，是 python 最通用的复合数据类型

　　l = ['jove', 10086, 2.23, 'H-H', 20.3]

　　print(l)

　　# ['jove', 10086, 2.23, 'H-H', 20.3]

　　列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表

　　从左到右索引默认 0 开始，从右到左索引默认 -1 开始

　　下标可以为空表示取到头或尾

　　print(l[-1]) # 输出列表的最后一个元素

　　print(l[1:3]) # 输出第二个至第三个元素

　　print(l[2:]) # 输出从第三个开始至列表末尾的所有元素

　　print(l[1:5:2]) # 输出字符串中第二个至第五个之间间隔2的元素

　　# 20.3

　　# [10086, 2.23]

　　# [2.23, 'H-H', 20.3]

　　# [10086, 'H-H']

　　Tuple(元组)

　　元组是另一个数据类型，类似于 List(列表)

　　元组用 () 标识。内部元素用逗号隔开

　　但是元组中的元素不能二次赋值，相当于只读列表

　　t = ('jove', 10086, 2.23, 'H-H', 20.3)

　　t[2] = 1000 # 元组中是非法应用

　　# TypeError: 'tuple' object does not support item assignment

　　Set(集合)

　　集合(set)是一个无序的不重复元素序列

　　可以使用大括号 { } 或者 set() 函数创建集合

　　s1 = {'g', 'o', 'o', 'g', 'l', 'e'}

　　s2 = {'g', 'o', 'o', 'g'}

　　print(s1, s2, s1 - s2)

　　# {'e', 'o', 'l', 'g'} {'o', 'g'} {'l', 'e'}

　　注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

　　Dictionary(字典)

　　字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型

　　列表是有序的对象集合，字典是无序的对象集合

　　两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取

　　字典用"{ }"标识。字典由索引(key)和它对应的值value组成

　　d = {'jove': 10086, 2.23: 'H-H'}

　　print(d[2.23])

　　print(d.keys())

　　print(d.values())

　　# H-H

　　# dict_keys(['jove', 2.23])

　　# dict_values([10086, 'H-H'])

　　4. 转换

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

　　以下几个内置的函数可以执行数据类型之间的转换

　　这些函数返回一个新的对象，表示转换的值

　　将x转换为一个整数

　　class int(x, base=10) # x ：字符串或数字，base ：进制数，默认十进制

　　print(int(12.0))

　　print(int("2e", 16)) # 但如果是带参数base的话，x 要以字符串的形式进行输入

　　# 12

　　# 46

　　将x转换到一个浮点数

　　class float([x]) # x：字符串或数字

　　print(float(-12))

　　print(float("20.3"))

　　# -12.0

　　# 20.3

　　创建一个复数

　　class complex([real[, imag]]) # real：int, float或字符串，imag：int, float

　　print(complex(1, 2))

　　print(complex("1+2j"))

　　# (1+2j)

　　# (1+2j)

　　将对象 x 转换为字符串

　　class str(object='') # object ：对象

　　str([10, 0, 86])

　　# '[10, 0, 86]'

　　将对象 x 转换为表达式字符串

　　class repr(object) # object ：对象

　　repr(str([10, 0, 86]))

　　# "'[10, 0, 86]'"

　　用来计算在字符串中的有效Python表达式,并返回一个对象

　　class eval(expression[, globals[, locals]])

　　# expression：表达式

　　# globals：变量作用域，全局命名空间，如果被提供，则必须是一个字典对象

　　# locals：变量作用域，局部命名空间，如果被提供，可以是任何映射对象

　　x = 7

　　print(eval('3 * x'))

　　# 21无锡人流医院 http://xmobile.wxbhnk120.com/

　　将序列 s 转换为一个元组

　　class tuple( seq ) # seq：要转换为元组的序列

　　print(tuple([1, 2, 3]))

　　# (1, 2, 3)

　　将序列 s 转换为一个列表

　　class list(tup) # tup：要转换为列表的元组

　　print(list((1, 2, 3)))

　　# [1, 2, 3]

　　转换为可变集合

　　class set([iterable]) # iterable：可迭代对象对象

　　print(set('google'))

　　# {'l', 'o', 'g', 'e'}

　　创建一个字典

　　class dict(**kwarg) # **kwargs：关键字

　　class dict(mapping, **kwarg) # mapping：元素的容器

　　class dict(iterable, **kwarg) # iterable：可迭代对象

　　# 必须是一个序列 (key,value)元组

　　print(dict(a='a', b='b', t='t')) # 传入关键字

　　print(dict(zip(['one', 'two', 'three'], [1, 2, 3]))) # 映射函数方式来构造字典

　　print(dict([('one', 1), ('two', 2), ('three', 3)])) # 可迭代对象方式来构造字典

　　# {'a': 'a', 'b': 'b', 't': 't'}

　　# {'one': 1, 'two': 2, 'three': 3}

　　# {'one': 1, 'two': 2, 'three': 3}

　　转换为不可变集合

　　class frozenset([iterable]) # iterable：可迭代的对象，比如列表、字典、元组等等

　　print(frozenset('google'))

　　# frozenset({'g', 'l', 'e', 'o'})

　　如果不提供任何参数，默认会生成空集合

　　将一个整数转换为一个字符

　　class chr(i) # i：数字

　　print(chr(48), chr(0x31), chr(0o62))

　　# 0 1 2

　　将一个字符转换为它的整数值

　　class ord(c) # c：字符

　　print(ord('6'), ord('A'), ord('a'))

　　# 54 65 97

　　将一个整数转换为一个十六进制字符串

　　class hex(x) # x：整数

　　print(hex(128))

　　# 0x80

　　将一个整数转换为一个八进制字符串

　　class oct(x) # x：整数

　　print(oct(1024))

　　# 0o2000

　　谢谢!