【Python】-1.Python数据类型及运算符

1. 常见类型

1.1 数字

在Python中最数字是一种常见的类型。

1.1.1加减乘除运算

print(3 + 2) # 5
print(8 - 6) # 2
print(16 - 3 * 2) # 10
print((17 - 2) / 5) # 3.0
print(8 / 5) # 1.6

注意，在python3中，”/“ 永远返回浮点类型的数；如果要返回整型，使用 “//“，但 “//“ 不会四舍五入，只去掉小数点后的数字

print(7 / 3) # 2.3333333333333335
print(7 // 3) # 2

1.1.2 指数运算

# 使用 “**” 来计算指数
print(5 ** 2) # 25
print(2 ** 7) # 128

1.1.3 变量赋值计算

width = 100
height = 3 * 7
print(width * height) # 2100

print(square) # NameError: name 'square' is not defined

如果一个变量未被定义过就被使用，会出现错误： NameError: name ‘square’ is not defined

1.1.4 复合运算

先统一类型再计算

print(5 * 7.1 + 3) # 38.5

1.2 字符串

除了数字，Python还可以处理字符串。

在Python中，’’ 或 “ ” 都可以表示字符串，\ 可以用来转义

1.2.1 常见字符串操作

print('How are you') # How are you
print('I\'m fine') # I'm fine
print("I'm fine") # I'm fine

如果不需要 ”\“ 被转义，在引号前面加上一个 r

print(r"C:windows\system32") # C:windows\system32
print(r'C:windows\system32') # C:windows\system32

如果要表示多行字符串，可以使用三个引号把字符串括起来，如 “”” … “”” 或 ‘’’ … ‘’’

print('''\
How are you? 
I'm fine!''')

How are you? 
I'm fine!

1.2.2 字符串拼接

python 可以使用 “+” 来连接两个字符串，使用 “*” 来重复字符串

print(3 * "am" + "fine") # amamamfine

两个或多个字符串相邻，会自动合并

print('Py' 'thon') # Python
print('today' 'is' 'a' 'nice' 'day') # todayisaniceday
text = 'Follow live text commentary from day two of Masters at Augusta National'
print(text) # Follow live text commentary from day two of Masters at Augusta National

print(3 * 'am' 'fine') # amfineamfineamfine

1.2.3 字符串索引

python 可以方便使用 “索引” 的方式获取字符串中的字符；索引从0开始

word = 'Python'
print(word[0]) # P
print(word[5]) # n
print(word[6]) # 超过边界出错：IndexError: string index out of range

如果索引是负数，从右向左计算（注意：0和-0都表示第一个字符）

word = 'Python'
print(word[-0]) # P
print(word[-1]) # n
print(word[-2]) # o
print(word[-6]) # P

1.2.4 字符串切片

截取字符串中的一段，使用 “切片” 操作，“:” 左边数字表示起始位置，“:” 右边数字表示结束位置；含头不含尾

word = 'Python'
print(word[0:2]) # Py
print(word[2:5]) # tho

如果省略 “:” 左边的数字，默认从头开始取； 如果省略 “:” 右边的数字，默认取到末尾

word = 'Python'
print(word[:2]) #  Py
print(word[2:]) #  thon
print(word[:2] + word[2:]) #  Python
print(word[:]) #  Python
print(word[-2:]) #  on

注意：切片的工作原理是将索引视为字符间的指向，第一个字符的左边缘编号为 0

#  +---+---+---+---+---+---+
#  | P | y | t | h | o | n |
#  +---+---+---+---+---+---+
#  0   1   2   3   4   5   6
#     -6  -5  -4  -3  -2  -1

使用索引时，如果索引值超出了边界，会报错；但如果使用的是 切片 的方式，解释器会自动忽略这个错误。

word = 'Python'
print(word[20]) # IndexError: string index out of range
print(word[2:20]) # thon
print(word[20:])

在 python 中，字符串是不能被改变的，无论是索引还是切片都只能获取字符串而不能被赋值

word = 'Python'
word[0]='a' # TypeError: 'str' object does not support item assignment
word[1:]="abcd" # TypeError: 'str' object does not support item assignment

# 如果想要一个和原来不一样的字符串，只能创建一个新的
word_new = 'J' + word[1:]
print(word_new) # Jython

python 内置函数 “len()” 可以返回字符串的长度

word = 'Python'
print(len(word)) # 6
print(len("你好")) # 2

1.3 列表

Python中可以将许多数据组合在一起，最常用的结构就是列表。在列表中可以存放不同类型的数据，但通常还是存放的相同类型。

1.3.1 列表的创建

squares = [1, 1, 2, 3, 5, 8]
print(squares) # [1, 1, 2, 3, 5, 8]

列表也能像字符串一样，使用索引和切片来获取部分元素

squares = [1, 1, 2, 3, 5, 8]
print(squares[0]) # 1
print(squares[4]) # 5
print(squares[2:5]) # [2, 3, 5]
print(squares[20]) # 超出范围出错：IndexError: list index out of range

使用负数作为索引

print(squares[-1]) # 8
print(squares[-3:]) # [3, 5, 8]

1.3.2 列表的赋值

一个列表赋值给另一个变量，只会拷贝变量的地址，不会拷贝里面的内容；改变其中一个变量的内容，另一个也会跟着改变

a = [1, 2]
b = a
print(b[0]) # 1
b[0] = 3
print(a) # [3, 2]

1.3.3 列表的切片

所有的切片操作都会返回一个新的列表，所以可以使用切片复制列表

c = [1, 2]
d = c[:]
print(d[0]) # 1
d[0] = 3
print(c) # [1, 2]
print(d) # [3, 2]

2. 其他类型

2.1 布尔

布尔类型是最简单的数据类型，只有两个值：False（假）和 True（真）

print(1 == 2) # False
print(10 == 10) # True
print(False == False) # True

2.2 常量

常量就是不能变的变量，比如常用的数字 π 就是一个常量。Python 在语法上并没有定义常量，大多数编程语言常常使用全大写的变量名表示常量，所以一般约定：如果名字全大写的变量就不要进行修改。

3. 运算符

3.1 算术运算符

主要包含： +、-、*、/、%、**、//

a = 10
b = 20
c = 7
d = 25
print(a + b) # 30
print(a - b) # -10
print(a - b - c) # -17
print(a * b) # 200
print(a / b) # 0.5
print(a / b / c) # 0.07142857142857142
print(a % b) # 10
print(a ** c) # 10000000
print(a // b) # 0
print(d // c) # 3

3.2 比较运算符

比较运算符，返回 True（真）或者 False（假）

主要包含：==、!=、>、<、>=、<=

a = 123
print(a < 100) # False
print(a > 100) # True
print(a <= 200) # True
print(a == 123) # True
print(a != 123) # False

3.3 赋值运算符

赋值运算符，把右边的结果赋值给左边的变量

主要包含：=、+=、-=、*=、/=、%=、**=、//=

a = 100
a += 10
print(a) # 110
a -= 10
print(a) # 100
a *= 10
print(a) # 1000
a /= 10
print(a) # 100.0
a %= 10
print(a) # 0.0
a = 100
a **= 2
print(a) # 10000
a //= 9
print(a) # 1111

3.4 位运算符

位运算符，对二进制进行位运算

主要包含：&(与运算)、|(或运算)、^(异或，相同取0，不同取1)、~(取反)、<<(左移)、>>(右移)

a = 9  # 0000 1001
b = 13  # 0000 1101
print(a & b)  # 1001  9
print(a | b)  # 1101  13
print(a ^ b)  # 0100  4
print(~a)  # 最高位取反，变成了负数  -10
print(a << 2)  # 9*2*2  36
print(a >> 2)  # 9/2/2  2

3.5 逻辑运算符

逻辑运算符，用于逻辑判断
主要包含：and、or、not

print(True and True) # True
print(True and False) # False
print(True or False) # True
print(not False) # True

3.6 关键字in和is

• in： 用于判断是否包含于指定的序列中
• is： 用于判断两个标识符是否引用同一个对象

# in
print(5 in (1, 2, 5, 8, 10)) # True
print(5 in (1, 2, 8, 10)) # False
print(5 not in (1, 2, 8, 10)) # True

# is
# 注意：is 和 == 的区别，is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等
a = 20
b = 20
print(a is b) # True
b = 30
print(a is b) # False

3.7 运算符优先级

从低到高的顺序

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments…)	函数调用
(experession,…)	绑定或元组显示
[expression,…]	列表显示
{key:datum,…}	字典显示
‘expression,…’	字符串转换

4. 表达式

表达式是Python最重要、最基础的组成元素。在Python中，绝大部分代码都是表达式。

下面的代码由两个表达式组成：

name = 'Python'
language = "Python"
# 对于变量值相同的情况，Python支持连续赋值
name = language = 'Python'