Python学习—03变量类型

变量赋值

  • Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。
  • 每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
  • 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
  • 等号（=）用来给变量赋值。
  • 等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

例如：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. counter = 100 # 赋值整型变量
  5. miles = 1000.0 # 浮点型
  6. name = "John" # 字符串
  8. print(counter)
  9. print(miles)
  10. print(name)

多个变量赋值

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

  1. a = b = c = 1

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

  1. a, b, c = 1, 2, "john"

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

常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。通常用大写字母表示常量。示例：

  1. PI = 3.14159265359

与PHP、JAVA的常量不一样，Python本身并没有提供常量这一机制。也就是说，在Python里，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

数据类型

Python提供的基本数据类型主要有：布尔类型、整型、浮点型、字符串、列表、元组、集合、字典等等。

Python有五个标准的数据类型：

  • Numbers（数字）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Dictionary（字典）

数字(number)

Python数字类型是不可改变的数据类型。

Python支持四种不同的数字类型：

  • int（有符号整型）
  • long（长整型[也可以代表八进制和十六进制]）
  • float（浮点型）
  • complex（复数）
  1. # 整数
  2. int=20;
  4. # 浮点数
  5. float=2.3;
  7. print(int)
  8. print(float)
  9. print(pow(2,5))
  10. print(2**5)

输出：

  1. 20
  2. 2.3
  3. 32
  4. 32

字符串(str)

a、使用单引号(‘)
用单引号括起来表示字符串，例如：

  1. str='this is string';
  2. print(str);

b、使用双引号(“)
双引号中的字符串与单引号中的字符串用法完全相同，例如：

  1. str="this is string";
  2. print(str);

c、使用三引号(‘’’)
利用三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号，例如：

  1. str='''this is string
  2. this is python string
  3. this is string'''
  5. print(str);

当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. str = 'Hello World!'
  6. print(str)           # 输出完整字符串
  7. print(str[0])        # 输出字符串中的第一个字符
  8. print(str[2:5])      # 输出字符串中第三个至第五个之间的字符串
  9. print(str[2:])       # 输出从第三个字符开始的字符串
  10. print(str * 2)       # 输出字符串两次
  11. print(str + "TEST")  # 输出连接的字符串

以上实例输出结果：

  1. Hello World!
  2. H
  3. llo
  4. llo World!
  5. Hello World!Hello World!
  6. Hello World!TEST

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

  1. >>> print('I\'m ok.')
  2. I'm ok.

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，可以自己试试：

  1. >>> print('\\\t\\')
  2. \       \
  3. >>> print(r'\\\t\\')
  4. \\\t\\

字符串通过encode()方法可以编码为指定的bytes，例如：

  1. >>> 'ABC'.encode('ascii')
  2. b'ABC'
  3. >>> '中文'.encode('utf-8')
  4. b'\xe4\xb8\xad\xe6\x96\x87'
  5. >>> '中文'.encode('ascii')
  6. Traceback (most recent call last):
  7.   File "<stdin>", line 1, in <module>
  8. UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

在bytes中，无法显示为ASCII字符的字节，用\x##显示。

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

  1. >>> b'ABC'.decode('ascii')
  2. 'ABC'
  3. >>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
  4. '中文'

可以使用str()将其它类型转为字符串类型。

列表(list)

List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
列表用[ ]标识。

列表中使用切片操作符[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。

加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  4. list = [ 'Hello', 786 , 2.23, 'john', 70.2 ]
  5. tinylist = [123, 'john']
  7. print(list)             # 输出完整列表
  8. print(list[0])            # 输出列表的第一个元素
  9. print(list[1:3])          # 输出第二个至第三个的元素 
  10. print(list[2:])           # 输出从第三个开始至列表末尾的所有元素
  11. print(tinylist * 2)       # 输出列表两次
  12. print(list + tinylist)    # 打印组合的列表

以上实例输出结果：

  1. ['Hello', 786, 2.23, 'john', 70.2]
  2. Hello
  3. [786, 2.23]
  4. [2.23, 'john', 70.2]
  5. [123, 'john', 123, 'john']
  6. ['Hello', 786, 2.23, 'john', 70.2, 123, 'john']

删除列表元素

  1. L=['spam', 'Spam', 'SPAM!'];
  2. del L[0]

列表函数&方法

  1. len(list) 列表长度
  2. list.append(obj) 在列表末尾添加新的对象，相当于其它语言里的push
  3. list.count(obj) 统计某个元素在列表中出现的次数
  4. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
  5. list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始
  6. list.insert(index, obj) 将对象插入列表
  7. list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
  8. list.remove(obj) 移除列表中某个值的第一个匹配项
  9. list.reverse() 反向列表中元素，倒转
  10. list.sort([func]) 对原列表进行排序

元组(tuple)

元组是另一个数据类型，类似于List（列表）。
元组用()标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

  1. tup = ();
  2. tup1 = ('physics', 'chemistry', 1997, 2000);
  3. tup2 = (1, 2, 3, 4, 5 );
  4. tup3 = "a", "b", "c", "d";

元组中只有一个元素时，需要在元素后面添加逗号，例如：tup1 = (50,);
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:

  1. tup1 = (12, 34.56);
  2. tup2 = ('abc', 'xyz');
  4. # 以下修改元组元素操作是非法的。
  5. # tup1[0] = 100;

元组中的元素值是不允许删除的，可以使用del语句来删除整个元组。

元组内置函数

  1. cmp(tuple1, tuple2) 比较两个元组元素。
  2. len(tuple) 计算元组元素个数。
  3. max(tuple) 返回元组中元素最大值。
  4. min(tuple) 返回元组中元素最小值。
  5. tuple(seq) 将列表转换为元组。

字典(dict)

字典是一种无序存储结构，包括关键字（key）和关键字对应的值（value）。字典的格式为：dictionary = {key:value}。key为不可变类型，如字符串、整数、只包含不可变对象的元组，列表等不可作为关键字。字典也被称作关联数组或哈希表。

示例：

  1. >>> dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

字典操作：

  1. # 访问
  2. >>> dict['name']  
  3. 'Zara'
  4. >>> dict['age']  
  5. 7
  7. # 修改
  8. >>> dict['name'] = 'yjc'
  9. >>> dict['name']
  10. 'yjc'
  11. >>> dict["school"]="wutong"
  12. >>> dict["school"]
  13. 'wutong'
  15. # 删除
  16. del dict['name'];  # 删除键是'name'的条目
  17. dict.clear();  # 清空词典所有条目
  18. del dict ;  # 删除词典

注意：字典不存在，del会引发一个异常。

字典内置函数方法：

  1. cmp(dict1, dict2) 比较两个字典元素。
  2. len(dict) 计算字典元素个数，即键的总数。
  3. str(dict) 输出字典可打印的字符串表示。
  4. type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
  5. dict.clear() 删除字典内所有元素
  6. dict.copy() 返回一个字典的浅复制
  7. dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
  8. dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
  9. dict.has_key(key) 如果键在字典dict里返回true，否则返回false
  10. dict.items() 以列表返回可遍历的(键, 值) 元组数组
  11. dict.keys() 以列表返回一个字典所有的键
  12. dict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
  13. dict.update(dict2) 把字典dict2的键/值对更新到dict里
  14. dict.values() 以列表返回字典中的所有值

集合(set)

集合(set)和字典(dict)类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

  1. >>> s = set([1, 2, 3])
  2. >>> s
  3. {1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

重复元素在set中自动被过滤：

  1. >>> s = set([1, 1, 2, 2, 3, 3])
  2. >>> s
  3. {1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

  1. >>> s1 = set([1, 2, 3])
  2. >>> s2 = set([2, 3, 4])
  3. >>> s1 & s2
  4. {2, 3}
  5. >>> s1 | s2
  6. {1, 2, 3, 4}

set 常用方法：

  1. s.add(key)
  2. s.remove(key)

布尔类型(bool)

在Python中，None、任何数值类型中的0、空字符串""、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了__nonzero__()或__len__()方法且方法返回0或False，则其实例也被当作False，其他对象均为True。

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，False，在Python中，可以直接用True、False（请注意大小写），也可以通过布尔运算计算出来：

  1. >>> True
  2. True
  3. >>> False
  4. False
  5. >>> 3 > 2
  6. True
  7. >>> 3 > 5
  8. False

布尔值可以用and(与)、or(或)和not(非)运算（逻辑运算符，并不是位运算符）：

  1. a = 10
  2. b = 20
  3. a and b  # 20
  4. a or b # 10
  5. not a # False
  6. not b # False

空值(None)

表示该值是一个空对象，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

参考

1、python数据类型详解 - Ruthless - 博客园
http://www.cnblogs.com/linjiqin/p/3608541.html
2、Python 变量类型 | 菜鸟教程
http://www.runoob.com/python/python-variable-types.html
3、数据类型和变量
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431658624177ea4f8fcb06bc4d0e8aab2fd7aa65dd95000
4、使用list和tuple
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014316724772904521142196b74a3f8abf93d8e97c6ee6000

作者： 飞鸿影
版权：本作品采用「署名-非商业性使用-相同方式共享 4.0 国际」许可协议进行许可。
出处：https://www.cnblogs.com/52fhy/p/6249825.html