Python学习笔记2：基本数据类型[Python基础]
Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
Python中有六个标准的数据类型：
数据类型 定义 可变性
Number（数字）
int, bool, float, complex，long(python2)
不可变数据
String（字符串）
单引号 " 或双引号 " 括起来，同时使用反斜杠 转义特殊字符
不可变数据
List（列表）
写在方括号 [] 之间、用逗号分隔开的元素列表
可变数据类型
Tuple（元组）
写在小括号 () 里，元素之间用逗号隔开
不可变数据
Set（集合）
使用大括号 { } 或者 set() 函数创建集合
可变数据类型
Dictionary（字典）
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
可变数据类型
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典；
对于字典：键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
Number（数字）
Python的数字类型有int整型、long长整型(python2)、float浮点数、complex复数、以及布尔值（0和1）。
可以通过内置的 type() 函数可以用来查询变量所指的对象类型，还可以用 isinstance 来判断类型：
var_int=123print(type(var_int))
var_float=1.01
print(type(var_float))
var_bool=True
print(type(var_bool))
var_complex=1+2j
print(type(var_complex))
print(isinstance(var_int, int))
print(isinstance(var_float, float))
输出结果如下：
<class "int"><class "float">
<class "bool">
<class "complex">
True
True
isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
注意：
1、在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
2、Python可以同时为多个变量赋值，如a, b = 1, 2。
3、一个变量可以通过赋值指向不同类型的对象。
4、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
5、在混合计算时，Python会把整型转换成为浮点数。
String（字符串）
Python中的字符串用单引号 " 或双引号 " 括起来，同时使用反斜杠 转义特殊字符。也可以字符串前面加r，表示的意思是禁止字符串转义。
字符串是不可修改的。所有关于字符我们可以从 索引、切片、长度、遍历、删除、分割、清除空白、大小写转换、判断以什么开头等方面对字符串进行介绍。
创建字符串
#字符串的形式：使用‘’或者“”来创建字符串var_str1="temp_string1"
print(var_str1)
var_str2="temp_string2"
print(var_str2)
1) 索引/切片
字符串也可以被截取(检索)。类似于C ，字符串的第一个字符索引为0 。Python没有单独的字符类型；一个字符就是一个简单的长度为1的字符串。
索引也可以是负数，这将导致从右边开始计算。除了索引，还支持切片。索引用于获得单个字符，切片让你获得一个子字符串。
如下，第一行数字给出字符串中的索引点 0…6。第二行给出相应的负索引。切片是从 i 到 j 两个数值标示的边界之间的所有字符。
+---+---+---+---+---+---+ | P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
索引也可以是负数，这将导致从右边开始计算。
>>> var_str="temp_string">>> var_str[1]
"e"
>>> var_str[-1]
"g"
>>> var_str[0:-2] # 从第一个到倒数第二个，不包含倒数第二个
"temp_stri"
注意，包含起始的字符，不包含末尾的字符。这使得 s[:i] + s[i:] 永远等于 s。
切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小。
>>> var_str="temp_string">>> var_str[2:]
"mp_string"
>>> var_str[:2]
"te"
>>>
2) 长度
内置函数 len() 返回字符串长度:
>>> s="thisisatestlongstring">>> len(s)
21
3) 删除
>>> s="python">>> del(s)
4) 大小写转换
>>> s="this is a string">>> print(s.capitalize())
This is a string
>>> print(s.title())
This Is A String
List（列表）
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。-1 为从末尾的开始位置。
>>> list=["abcd", 123, 4.56, "python", 789]>>> print(list)
["abcd", 123, 4.56, "python", 789]
>>> print(list[0])
abcd
>>> print(list[1:3])
[123, 4.56]
>>> print(list[2:])
[4.56, "python", 789]
>>> print(list[:-1])
["abcd", 123, 4.56, "python"]
与字符串不一样的是，列表中的元素是可以改变的：
>>> list=["abcd", 123, 4.56, "python", 789]>>> print(list[2])
4.56
>>> list[2]=100.1 #更新列表中第三个元素
>>> print(list)
["abcd", 123, 100.1, "python", 789]
>>> del list[1] #删除列表中第二个元素
>>> print(list)
["abcd", 100.1, "python", 789]
与字符串截取不同，列表截取可以接收第三个参数，参数作用是截取的步长。如果第三个参数为负数表示逆向读取。
以下实例在索引 1 到索引 8 的位置并设置为步长为 2（间隔一个位置）来截取字
>>> list=[1,2,3,4,5,6,7,8,9,0]>>> print(list[1:8:2])
[2, 4, 6, 8]
>>> print(list[-3:-10:-2]) #逆向截取，从倒数第三个元素开始到倒数第十个，逆向截取步长为2
[8, 6, 4, 2]
还可以使用嵌套列表即在列表里创建其它列表：
>>> list=[1, ["a","b"], 2]>>> print(list[1])
["a", "b"]
>>> print(list[1][1])
b
Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。
元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型也可以不相同。
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
>>> tup=(50)>>> type(tup)
<class "int">
>>> tup1=(50,) # 一个元素，需要在元素后添加逗号
>>> type(tup1)
<class "tuple">
Set（集合）
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
>>> s={1, 2, 3}>>> print(s)
{1, 2, 3}
>>> s=set((1, 2, 3))
>>> print(s)
{1, 2, 3}
Dictionary（字典）
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2, key3 : value3 }列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
>>> dict1={}>>> dict1["name"]="Python"
>>> dict1["age"]=18
>>> print(dict1)
{"name": "Python", "age": 18}
>>> dict2={"name":"python", "age":18}
>>> print(dict2)
{"name": "python", "age": 18}
>>> print(dict2.keys())
dict_keys(["name", "age"])
>>> print(dict2.values())
dict_values(["python", 18])
>>> dict3=dict([("name", "python"), ("age", 1)]) #(key, value)元组序列创建字典
>>> print(dict3)
{"name": "python", "age": 1}
>>> dict4=dict(name="python", age=18) # 关键字创建字典
>>> print(dict4)
{"name": "python", "age": 18}
删除字典元素，能删单一的元素也能清空字典：
>>> dict={"name": "python", "age": 18}>>> del dict["age"]
>>> print(dict)
{"name": "python"}
>>> dict.clear()
>>> print(dict)
{}
>>> del dict
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
>>> dict={"name": "python", "age": 18, "name":"lily"}>>> print(dict)
{"name": "lily", "age": 18}
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
>>> dict={["name"]: "python", "age": 18}Traceback (most recent call last):
File "<pyshell#57>", line 1, in <module>
dict={["name"]: "python", "age": 18}
TypeError: unhashable type: "list"
以上是 Python学习笔记2：基本数据类型[Python基础] 的全部内容， 来源链接： utcz.com/z/529907.html
