Python学习笔记2:基本数据类型

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=123

print(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:基本数据类型 的全部内容, 来源链接: utcz.com/z/537644.html

回到顶部