数据类型
Python常用数据类型
➢在Python中变量不直接存储值，而是存储值的内存地址或者引用。
➢在Python中，不需要事先声明变量名及其类型，使用赋值语句可以直接创建任意类型的变量，变量的类型取决于等号右侧表达式值的类型。
➢赋值(比如a= 'ABC' )时，Python解释器干了两件事:
➢在内存中创建一个'ABC'的字符串
➢在内存中创建一个名为a的变量，并把它指向str
◆Number (数字)
➢Python支持int(整型), float(浮点型), complex(复数)三种不同的数字类型
>>> a=3
>>> b=3.14
>>>c=3 + 4j
>>> print(type(a), type(b), type(c))
<class 'int'> <class 'float'> <class 'complex'>
>>> isinstance(a, int) #判断变量a是不是整型
True
◆Number (数字)示例代码
import math
print (math. factorial(32)) #计算32的阶乘
print(0.4-0.3 == 0.1) #实数之间尽量避免直接比较大小
print(math. isclose(0.4-0.3, 0.1)) #测试两个实数是否足够接近
C = 3+4j # Python内置支持复数及其运算
print(C+C ) #复数相加
print(c.real) #查看复数的实部
print(C.imag) #查看复数的虚部
print(3+4j.imag) #相当于3+(4j).imag
263130836933693530167218012160000000
False
True
False
(6+8j)
3.0
4.0
7.0
◆String (字符串)
➢Python中的字符串可以使用单引号、双引号和三引号(三个单引号或三个双引号)括起来,使用反斜杠转义特殊字符
➢Python3源码文件默认以UTF-8编码，所有字符串都是unicode字符串
➢支持字符串拼接、截取等多种运算
>>> a= "Hello"
>>> b = "Python"
>>> print"a + b输出结果: ",a+ b)
a + b输出结果: HelloPython
>>> print("a[1:4]输出结果: "， a[1:4])
a[1:4]输出结果: ell
text = '''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.'''
print(len(text)) # 字符串长度，即所有字符的数量
print(text.count('is')) # 字符串中单词is出现的次数
print('Beautiful' in text) # 测试字符串中是否包含单词beautiful
print('='*20) # 字符串重复
print('Good '+'Morning') # 字符串连接
208
6
True
====================
Good Morning
◆List (列表)
➢列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。
➢列表是写在方括号[]之间、用逗号分隔开的元素列表。
➢列表索引值以0为开始值，-1为从末尾的开始位置。
➢列表可以使用+操作符进行拼接,使用*表示重复。
>>> list = ['abcd', 786，2.23, 'runoob', 70.2]
>>> print(list[1:3])
[786, 2.23]
>>> tinylist = [123, 'runoob']
>>> print(list + tinylist)
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob]
◆Tuple (元组)
➢tuple与list类似， 不同之处在于tuple的元素不能修改。tuple写在小括号里，元素之间用逗号隔开。
➢元组的元素不可变,但可以包含可变对象，如list。
注意:定义一个只有1个元素的tuple,必须加逗号。
>>> t= (abcd', 786，2.23, 'runoob', 70.2)
>>>t1 =(1, )
>>> t2=('a', 'b', ['A'; 'B'])
>>> t[2][0]= 'X'
>>> t
("a', 'b', [X;, 'B"])
◆dict (字典)
➢字典是无序的对象集合,使用键-值(key-value) 存储，具有极快的查找速度。
➢键(key)必须使用不可变类型。
➢同一个字典中，键(key)必须是唯一的。
>>> d = {'Michael: 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael]
95
◆set (集合)
➢set和dict类似， 也是一组key的集合, 但不存储value。由于key不能重复，所以，在set中，没有重复的key。
➢set是无序的，重复元素在set中自动被过滤。
>>>s= set([1,2, 3])
>>> s
{1, 2, 3}
>>> s= set([1, 1,2, 2, 3, 3])
>>> s
{1, 2, 3}
◆列表、元组、字典与集合综合示例代码
# 创建列表对象
x_list = [1, 2, 3]
# 创建元组对象
x_tuple = (1, 2, 3)
# 创建字典对象，元素形式为“键:值”
x_dict = {'a':97, 'b':98, 'c':99}
# 创建集合对象
x_set = {1, 2, 3}
# 使用下标访问列表中指定位置的元素，元素下标从0开始
print(x_list1)
# 元组也支持使用序号作为下标，1表示第二个元素的下标
print(x_tuple1)
# 访问字典中特定“键”对应的“值”，字典对象的下标是“键”
print(x_dict['a'])
# 查看列表长度，也就是其中元素的个数
print(len(x_list))
# 查看元素2在元组中首次出现的位置
print(x_tuple.index(2))
# 查看字典中哪些“键”对应的“值”为98
for key, value in x_dict.items():
if value == 98:
print(key)
# 查看集合中元素的最大值
print(max(x_set))
2
2
97
3
1
b
3
运算符
◆算术运算符
Tips:
➢ +运算符除了用于算术加法以外，.还可以用于列表、元组、字符串的连接。
➢ -运算符除了用于整数、实数、复数之间的算术减法和相反数之外，还可以计算集合的差集。需要注意的是，在进行实数之间的运算时，有可能会出现误差。
➢ *运算符除了表示整数、实数、复数之间的算术乘法,还可用于列表、元组、字符串这几个类型的对象与整数的乘法，表示序列元素的重复，生成新的列表、元组或字符串。
➢ %运算符可以用于求余数运算,还可以用于字符串格式化。
# +运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接
print(3 + 5)
print(3.4 + 4.5)
print((3+4j) + (5+6j))
print('abc' + 'def')
print([1,2] + [3,4])
print((1,2) + (3,))
print("
")
8
7.9
(8+10j)
abcdef
[1, 2, 3, 4]
(1, 2, 3)
# -运算符除了用于整数、实数、复数之间的算术减法和相反数之外，还可以计算集合的差集。需要注意的是，在进行实数之间的运算时，有可能会出现误差。
print(7.9 - 4.5) # 注意，结果有误差
print(5 - 3)
num = 3
print(-num)
print(--num) # 注意，这里的--是两个负号，负负得正
print(-(-num)) # 与上一行代码含义相同
print({1,2,3} - {3,4,5}) # 计算差集
print({3,4,5} - {1,2,3})
print("
")
3.4000000000000004
2
-3
3
3
{1, 2}
{4, 5}
# *运算符除了表示整数、实数、复数之间的算术乘法，还可用于列表、元组、字符串这几个类型的对象与整数的乘法，表示序列元素的重复，生成新的列表、元组或字符串。
print(33333 * 55555)
print((3+4j) * (5+6j))
print('重要的事情说三遍！' * 3)
print([0] * 5)
print((0,) * 3)
print("
")
1851814815
(-9+38j)
重要的事情说三遍！重要的事情说三遍！重要的事情说三遍！
[0, 0, 0, 0, 0]
(0, 0, 0)
# %运算符可以用于求余数运算，还可以用于字符串格式化。在计算余数时，结果与%右侧的运算数符号一致。
print(365 % 7)
print(365 % 2)
print('%c,%c, %c' % (65, 97, 48)) # 把65、97、48格式化为字符
1
1
A,a, 0
◆比较运算符
◆比较运算符示例
print(3+2 < 7+8) # 关系运算符优先级低于算术运算符
print(3 < 5 > 2) # 等价于3<5 and 5>2
print(3 == 3 < 5) # 等价于3==3 and 3<5
print('12345' > '23456') # 第一个字符'1'<'2'，直接得出结论
print('abcd' > 'Abcd') # 第一个字符'a'>'A'，直接得出结论
print([85, 92, 73, 84] < [91, 82, 73]) # 第一个数字85<91，直接得出结论
print([180, 90, 101] > [180, 90, 99]) # 前两个数字相等，第三个数字101>99
print({1, 2, 3, 4} > {3, 4, 5}) # 第一个集合不是第二个集合的超集
print({1, 2, 3, 4} <= {3, 4, 5}) # 第一个集合不是第二个集合的子集
print([1, 2, 3, 4] > [1, 2, 3]) # 前三个元素相等
# 并且第一个列表有多余的元素
True
True
True
False
True
True
True
False
False
True
◆赋值运算符
◆逻辑运算符
print(3 in range(5) and 'abc' in 'abcdefg')
print(3-3 or 5-2)
print(not 5)
print(not [])
True
3
False
True
◆成员运算符
print(60 in [70, 60. 50. 80])
print('abc' in 'alb2c3dfg')
print([3] in [[3],[4],[5]]
print('3' in ma[(str,range(5)))
print(5 in range(5))
True
False
True
True
False
◆身份运算符
a = 20
b = 20
if ( a is b ):
print ("1 : a 和 b 有相同的标识")
else:
print ("1 : a 和 b 没有相同的标识")
print(id(a))
print(id(b))
# 修改变量 b 的值
b = 30
if ( a is b ):
print ("3 : a 和 b 有相同的标识")
else:
print ("3 : a 和 b 没有相同的标识")
1 : a 和 b 有相同的标识
1378154720
1378154720
3 : a 和 b 没有相同的标识
# is 与 == 的区别
a = [1, 2, 3]
b = [1, 2, 3]
print(b == a)
print(b is a)
print(id(a))
print(id(b))
True
False
46189224
46941192
◆运算符优先级
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：", e)
e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：", e)
e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 运算结果为：", e)
# print(8 / 2 * (2 + 2))
(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0