Python3学习笔记(二)【基本数据类型】
Python
中的变量不需要声明。每个变量使用前必须赋值,变量赋值以后变量才会创建。
在Python
中,变量就是变量,它没有类型,我们所说的”类型”是变量所指的内存中对象的类型。
如:
_name = "qfxl"
_age = 100
_weight = 66.6
多个变量赋值
Python
允许为多个变量同时赋值。
a = b = c = 0
以上实例,创建一个整型对象,值为0,从后向前赋值,三个变量都指向同一个内存地址。
也可以为多个变量同时赋值。
_name, _age, _weight = "qfxl", 100, 66.6
print(_name, _age, _weight)
输出
qfxl 100 66.6
标注数据类型
Python3
中有6个标准的数据类型:
- Number(数字)
- String(字符串)
- List(列表)
- Tuple(元祖)
- Set(集合)
- Dictionary(字典)
Python3
中6个标准的数据类型中:
- 不可变数据: Number、String、Tuple
- 可变数据: List、Set、Dictionary
Number(数字)
Python3
中支持int
、float
、bool
、complex(复数)
。
在Python3
中,只有一种整型int
表示为长整型,没有Python2
中的Long
。
内置函数type()
可以用来查询变量对应的数据类型。
_name = "qfxl"
_age = 100
_weight = 66.6
_complex = 1+1j
print(type(_name), type(_age), type(_weight), type(_complex))
输出:<class 'str'> <class 'int'> <class 'float'> <class 'complex'>
此外还能用内置函数isinstance()
来判断:
_name = "qfxl"
_age = 100
_weight = 66.6
_complex = 1 + 1j
print(isinstance(_name, str), isinstance(_age, int), isinstance(_weight, float), isinstance(_complex, complex))
输出:
True True True True
type()
跟isinstance()
的区别在于:
type()
不会认为子类属于父类型。isinstance
认为子类属于父类型。
class A:
pass
class B(A):
pass
print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)
输出:
True
True
True
False
注意:在 Python2 中是没有布尔型的,它用数字 0 表示 False,用 1 表示 True。到 Python3 中,把 True 和 False 定义成关键字了,但它们的值还是 1 和 0,它们可以和数字相加。
_b = True
print(_b + 1) # 输出2
在Python
中可以使用del
来删除对象引用。
_a = 0
_b = 1
_c = 2
_d = 3
_f = 4
del _a
print(_a)
这里会报错:
Traceback (most recent call last):
File “Sample.py”, line 9, in
print(_a)
NameError: name ‘_a’ is not defined
也可以同时删除多个引用。
_a = 0
_b = 1
_c = 2
_d = 3
_f = 4
del _a, _b, _c
数值运算。
注意:
- 一个变量可以通过赋值指向不同类型的对象。
- 数值的出发包括两种,
/
,//
,/
返回一个浮点数,//
返回一个整数。 - 在混合运算是,
Python
会将整型转换成浮点型。
数值类型实例。
int | float | complex |
---|---|---|
10 | 0.0 | 3.14j |
100 | 15.20 | 45.j |
-786 | -21.9 | 9.322e-36j |
0x69 | 70.2E-12 | 4.53e-7j |
Python
还支持复数,复数由实数根虚数构成,复数的实部和虚部都是浮点型。
_x = 1 + 1j
print(_x)
输出:
(1+1j)
_sum = 1 + 1 # 结果为2 (加)
_sub = 2.5 - 2 # 结果为0.5 (减)
_multi = 2 * 10 # 结果为20 (乘)
_division = 11 / 5 # 结果为2.2(浮点数)
_divisionInt = 11 // 5 # 结果为2(整数)
_remain = 3 % 2 # 结果为1 (取余)
_squares = 2 ** 3 # 结果为8 (乘方)
print(_sum, _sub, _multi, _division, _divisionInt, _remain, _squares)
输出:
2 0.5 20 2.2 2 1 8
String(字符串)
Python
中的字符串用''
或者""
,使用\
表示转义字符。
字符串的截取语法:
变量[头下标:尾下标]
索引值以0为开始值,-1为从末尾的开始位置。
_str = "qfxl"
print(_str) # 输出字符串 qfxl
print(_str[0:-1]) # 输出第一个到倒数第二个字符串 qfx
print(_str[0]) # 输出第一个字符 q
print(_str[1:3]) # 输出第二个到第三个字符 fx
print(_str[1:]) # 输出从第二个开始到后面所有的字符 fxl
print(_str * 2) # 输出两次字符串 qfxlqfxl
print(_str + "哈哈") # 输出拼接字符串 qfxl哈哈
Python
使用\
表示转义特殊字符,如果想让转义失效,在前面加上r
。
_str = "my name \n is qfxl"
print(_str)
_str = r"my name \n is qfxl"
print(_str)
输出:
my name
is qfxl
my name \n is qfxl
另外,反斜杠\
可以作为续行符,表示下一行是上一行的延续。也可以使用 """..."""
或者 '''...'''
跨越多行。
注意,Python 没有单独的字符类型,一个字符就是长度为1的字符串。
_str = "my name \
is qfxl"
print(_str)
输出:
my name is qfxl
与C
字符串不同的是,Python
的字符串不能被改变,向一个索引位置赋值会导致报错,如:
_str = "qfxl"
_str[0] = "a"
Traceback (most recent call last):
File “Sample.py”, line 2, in
_str[0] = “a”
TypeError: ‘str’ object does not support item assignment
总结:
\
可以用来转义,r
可以让转义失效。- 字符串用
+
可以连接在一起,用*
运算符重复。 Python
中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。Python
中的字符串不能改变。
List(列表)
List(列表)
是Python
中使用最频繁的数据类型。
列表可以完成大多数集合类数据结构的实现,列表中的元素可以不相同,支持数字,字符串甚至包含列表(俗说的嵌套)。
列表是写在方括号[]
之间,用,
分隔分隔开的元素列表。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
列表的截取语法:
变量[头下标:尾下标]
索引以从左往右0为起始,从右往左-1为起始。
+
是列表连接运算符,*
是重复运算符。
_list = ["Anna", "Bruce", "qfxl", 100, True]
_tinyList = _list[0:1]
print(_list) # 输出['Anna', 'Bruce', 'qfxl', 100, True]
print(_list[0]) # 输出Anna
print(_list[0:1]) # 输出['Anna']
print(_list[1:]) # 输出['Bruce', 'qfxl', 100, True]
print(_tinyList) # 输出['Anna']
print(_tinyList * 2) # 输出['Anna', 'Anna']
print(_tinyList + _list) # 输出['Anna', 'Anna', 'Bruce', 'qfxl', 100, True]
输出
[‘Anna’, ‘Bruce’, ‘qfxl’, 100, True]
Anna
[‘Anna’]
[‘Bruce’, ‘qfxl’, 100, True]
[‘Anna’]
[‘Anna’, ‘Anna’]
[‘Anna’, ‘Anna’, ‘Bruce’, ‘qfxl’, 100, True]
与字符串不同的是,List
的元素是可以改变的。
_list = [True, "Bruce", "qfxl"]
_list[0] = "Hello"
print(_list)
_list[1:] = []
print(_list)
输出:
[‘Hello’, ‘Bruce’, ‘qfxl’]
[‘Hello’]
总结:
List
写在[]
之间,元素用,
分开。- 和字符串一样,
List
可以被索引跟切片。 List
可以用+
来拼接。List
的元素是可以改变的。
Tuple(元组)
Tuple(元组)
与List
类似,不同之处包括Tuple
的元素,Tuple
的元素写在()
之间,Tuple
中的元素也可以不相同。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
列表的截取语法:
变量[头下标:尾下标]
索引以从左往右0为起始,从右往左-1为起始。
_tuple = ("Anna", "Bruce", "qfxl", 100, True)
_tinyTuple = _tuple[0:2]
print(_tuple) # 输出('Anna', 'Bruce', 'qfxl', 100, True)
print(_tuple[0]) # 输出Anna
print(_tuple[0:3]) # 输出('Anna', 'Bruce', 'qfxl')
print(_tuple[1:]) # 输出('Bruce', 'qfxl', 100, True)
print(_tinyTuple) # 输出('Anna', 'Bruce')
print(_tinyTuple * 2) # 输出('Anna', 'Bruce', 'Anna', 'Bruce')
print(_tinyTuple + _tuple) # 输出('Anna', 'Bruce', 'Anna', 'Bruce', 'qfxl', 100, True)
Tuple
不支持修改元素。
_tuple = ("Anna", "Bruce", "qfxl", 100, True)
_tuple[0] = True
Traceback (most recent call last):
File “Sample.py”, line 2, in
_tuple[0] = True
TypeError: ‘tuple’ object does not support item assignment
虽然Tuple
的元素不可改变,但是它可以包含可变对象,如List
。
构造包含0个或1个元素的Tuple
比较特殊。
_tupleEmpty = () # 空元组
_tupleTiny = (1,) # 一个元素,需要在元素后添加逗号
String
、List
、Tuple
都属于sequence(序列)。
总结:
- 与字符串一样,
Tuple
的元素不可修改。 Tuple
可以被索引和切片。- 注意构造0个跟1个
Tuple
的写法。 Tuple
也可以用+
来拼接,*
来重复。
set(集合)
set
是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
set
可以使用{}
或者set()
函数来创建。
注意:创建一个空集合需要使用set()
而不是{}
,因为{}
是用来创建一个空字典。
_set = {"a", "b", "c"}
_setTiny = set("abc")
_setEmpty = set()
print(_set)
print(_setTiny)
print(_setEmpty)
输出:
{‘c’, ‘a’, ‘b’}
{‘c’, ‘a’, ‘b’}
set()
set
会剔除重复元素:
_set = {"a", "b", "c", "a", "b"}
print(_set)
输出:
{‘b’, ‘a’, ‘c’}
set
成员测试:
_set = {"a", "b", "c"}
if "a" in _set:
print("a 在 _set 里")
else:
print("a 不在 _set 里")
set
集合运算:
_setA = set("abc")
_setB = set("cde")
print(_setA - _setB) #_setA 和 _setB的差集
print(_setA | _setB) # _setA 和 _setB的并集
print(_setA & _setB) # _setA 和 _setB的交集
print(_setA ^ _setB) # _setA 和 _setB不同时存在的元素
输出:
{‘a’, ‘b’}
{‘b’, ‘c’, ‘d’, ‘e’, ‘a’}
{‘c’}
{‘e’, ‘d’, ‘b’, ‘a’}
Dictionary(字典)
Dictionary
是python
中非常有用的一种内置数据类型。
列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典是一种映射类型,字典用”{ }”标识,它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中,键(key)必须是唯一的。
_dic = {}
_dic["name"] = "qfxl"
print(_dic)
_dicB = {"name": "qfxl", "age": 100}
print(_dicB)
_dicComplex = {"name": "qfxl", "age": 100, "isHandsome": True}
print(_dicComplex["name"])
print(_dicComplex["isHandsome"])
print(_dicComplex.keys())
print(_dicComplex.values())
输出:
{‘name’: ‘qfxl’}
{‘name’: ‘qfxl’, ‘age’: 100}
qfxl
True
dict_keys([‘name’, ‘age’, ‘isHandsome’])
dict_values([‘qfxl’, 100, True])
总结:
- 字典是一种映射类型,它的元素是键值对。
- 字典中的关键字必须为不可变类型,且不能重复。
- 创建空字典用
{}
。
Python数据类型转换。
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
函数 | 描述 |
---|---|
int(x [,base]) | 将x转换为一个整数 |
float(x) | 将x转换到一个浮点数 |
complex(real [,imag]) | 创建一个复数 |
str(x) | 将对象 x 转换为字符串 |
repr(x) | 将对象 x 转换为表达式字符串 |
eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s) | 将序列 s 转换为一个元组 |
list(s) | 将序列 s 转换为一个列表 |
set(s) | 转换为可变集合 |
dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组。 |
frozenset(s) | 转换为不可变集合 |
chr(x) | 将一个整数转换为一个字符 |
ord(x) | 将一个字符转换为它的整数值 |
hex(x) | 将一个整数转换为一个十六进制字符串 |
oct(x) | 将一个整数转换为一个八进制字符串 |