二、Python变量

变量

Python中的变量无需声明，变量赋值后该变量才会被创建，没有类型，所谓数据类型指的是变量所指内存中对象的类型

交互模式中，最后输出的表达式结果自动赋值给变量 _
_是只读的，不需要显示赋值，否则就会变为同名局部独立变量，屏蔽掉内置变量

>>> a=1
>>> b=2
>>> a+b
3
>>> _
3
>>> _+5
8
>>> _
8

del，是删除对象的引用，并非删除数据

a=1 #一个int对象被创建
del a #删除对a的引用，但1仍在内存中
del a,b,c #删除多个

运算符

算术运算符

运算符	描述	a=10 b=21
+	加	a + b = 31
-	减	a - b = -11
*	乘	a * b = 210
/	除	b / a = 2.1
%	取余	b % a = 1
**	幂	a**b = 1000000000000000000000
//	取整	a // b =0

比较运算符

运算符	描述	a=10 b=21
==	等于	(a == b) 返回 False
!=	不等于	(a != b) 返回 True
>	大于	(a > b) 返回 False
<	小于	(a < b) 返回 True
>=	大于等于	(a >= b) 返回 False
<=	小于等于	(a <= b) 返回 True

赋值运算符

a=1  #单变量赋值
a=b=c=1  #多变量赋同值
a,b,c=1,2,"hello"  #多变量分别赋值

运算符	描述
=	简单赋值	c = a + b
+=	加法赋值	c +=a 相当于 c = c + a
-=	减法赋值	c -=a 相当于 c = c - a
*=	乘法赋值	c *=a 相当于 c = c * a
/=	除法赋值	c /=a 相当于 c = c / a
%=	取余法赋值	c %=a 相当于 c = c % a
**=	幂赋值	c **=a 相当于 c = c ** a
//=	取整赋值	c //=a 相当于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值，Python3.8 版本新增

海象运算符

特殊的表达式，返回值是等号右边表达式的值

• 不能单独成行
• 不能被赋值语句单独使用

a = 1
if a > 0:
	print("1>0")
相当于
if a:=1 > 0:
	print("1>0")

逻辑运算符

运算符	描述	a = 10 b = 20
and	布尔与， 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值
or	布尔或，如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值
not	布尔非，如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

位运算符

运算符	描述
&	按位与，同1才1
|	按位或，有1就1
^	按位异或，不同则1
~	按位取反，10互换
<<	左移，低位补0
>>	右移，高位补0

成员运算符

运算符	描述
in	指定的序列中找到值返回 True，否则返回 False
not in	指定的序列中没有找到值返回 True，否则返回 False

身份运算符

比较两个对象的存储单元，id()获取对象内存地址

运算符	描述
is	判断两个标识符是不是引用自一个对象，是则返回 True，否则返回 False	x is y, 类似 id(x) == id(y)
is not	判断两个标识符是不是引用自不同对象，不是则返回 True，否则返回 False	x is not y ， 类似 id(x) != id(y)

优先级

从最高到最低，相同优先级从左到右运算

数据类型

不可变数据类型：改变值就意味着要重新分配内存空间，Number数字、String字符串、Tuple元组
可变数据类型：List列表、Dictionary字典、Set集合

type()查询变量对应数据类型

isinstance()判断变量对应数据类型

• 区别在于：
  type()不认为子类是一种父类类型
  isinstance()会认为子类是一种父类类型
  

Number数字（不可变）

python3中支持int（Python3中没有限制大小，可当作long型）、bool、float、complex（实部和虚部都是浮点型）

bool是int的子类，1和0表示True和False，可与数字相加，is判断可知并非int（Python2中没有布尔型，用0、1表示）

数值运算，混合计算时会将整型转换为浮点数

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到浮点数
0.5
>>> 2 // 4 # 取整，数据类取决于分子分母
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

bool布尔

布尔类型即True或False，判断条件是否成立以可以控制程序流程

• 只有两个值，True、False
• 与其他数据类型比较 / 转换时，True为1，False为0
• 与逻辑运算符使用组合成布尔表达式
• 非零 / 非空数据类型都视为True，0 / 空数据类型都视为False

String字符串（不可变）

索引以0为开始值，-1为末尾开始值，用单引号 ’ 或双引号 " 括起来

如果字符串本身有单引号，就用双引号括起来

索引越界会报错！但切片会自动处理索引！

Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
Python3中，所有的字符串都是Unicode字符串。

str = 'Runoob'
print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str[:2])      # 输出前两个字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

转义字符

如不转义，字符串前加r或R以表示原始字符，如print(r'h\ello')

转义字符	描述
\	换行
\	反斜杠
’	单引号
"	双引号
\a	响铃
\b	退格
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成
\f	换页
\yyy	八进制
\xyy	十六进制
\other	其它的字符以普通格式输出

print("Hello \v World!")
print("Hello \t World!")
print('google runoob taobao\r123456')
print("Hello \f World!")
print("\110\145\154\154\157\40\127\157\162\154\144\41")
print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")

多行字符串

'''或''''括起来可指示多行字符串，其中可自由使用单引号或双引号

# 字符串中将自动包括行结束符，但也可以在换行的地方添加一个 \ 来避免此情况
print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

格式化

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
# 输出结果：我叫 小明 今年 10 岁!

符号	描述
%c	字符
%s	字符串
%d	整数
%u	无符号整型
%o	无符号八进制数
%x	无符号十六进制
%X	无符号十六进制（大写）
%f	浮点数，可指定精度
%e	科学计数法浮点数
%E	同%e
%g	%f和%e的简写
%G	%F和%E的简写
%p	十六进制格式化变量

对于字面值可合并的，python会自动合并，变量的合并要用加号

f-string

3.6版本后出现的，称为字面量格式化字符串
以 f 开头，后面跟字符串，字符串中的表达式用大括号 {} 包起来，会替换变量或表达式计算后的值

name = 'Runoob'
# 替换变量  
print(f'Hello {name}')
# 使用表达式  
print(f'{1+2}')

# 输出结果  
Hello Runoob  
3 

3.8版本中可以使用=拼接表达式与结果

bytes二进制（不可变）

python3新增类型

bytes表示的是不可变的二进制序列，通常用于处理二进制数据，如图像文件、音频文件、视频文件等，网络编程中也可用来传输二进制数据

不同于string，bytes中的元素是整数值（0-255），不是unicode字符，因此需使用整数值来比较

ord()，将字符转换为相应的整数值

创建方法：
1、b前缀，x = b"abc"
2、bytes()数据类型转换，x = bytes("abc", encoding="utf-8")，第二个参数默认为utf-8

List列表

索引以0为开始值，-1为末尾开始值

Python中使用最频繁的数据类型，支持大多数集合类的数据结构实现，元素类型可以不同，支持嵌套列表

列表元素能被改变

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[1:5:2])     # 从第二个到第五个，步长为2（间隔一个位置）
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

Tuple元组（不可变）

索引以0为开始值，-1为末尾开始值

与List类似，但元组元素不可修改，写在小括号内，逗号隔开，元素类型可以不同，可以截取

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

元组元素不能被改变，但可以包含可变的对象，比如List。因为List中的元素变化不会导致List对象的内存地址变化，因此对Tuple来说，元素并没有发生变化。

注意：不可以将List整体替换，这样会改变内存地址
参考：https://blog.csdn.net/ygfrancois/article/details/93852805

Set集合

使用大括号{ }或者set()函数创建集合，没有索引，通过in进行成员测试，可做集合运算

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites:
    print('Runoob 在集合中')
else:
    print('Runoob 不在集合中')

# 集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

Dictionary字典

元素通过键值对来声明，key不能重复，没有索引，是python中唯一的映射类型

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

对比

注：html中的空格
 按下space键产生的空格
 占据宽度是1/2个中文，基本上不受字体影响
 占据宽度1个中文，基本上不受字体影响

	String	List	Tuple	Set	Dictionary
格式	string = ‘ ’	list = [ ]	tuple = ( )	set = { } 或set( )	dict = { }
创空	string = ‘ ’	list = [ ]	tuple = ( )	set( )	dict = { }
索引	索引以0为开始值，-1为末尾开始值			没有索引
	以string为例，list和tuple同理 prin(str)      # 输出字符串 print(str[0:-1])    # 输出第一个到倒数第二个的所有字符 print(str[0])      # 输出字符串第一个字符 print(str[2:5])   # 输出从第三个开始到第五个的字符 print(str[2:])     # 输出从第三个开始的后的所有字符 print(str*2)    # 输出字符串两次，也可以写成 print (2 * str) print(str+"test")  # 连接字符串
元素	不能改变	可以改变	不能改变，但可包含可变的list	唯一	key唯一

数据类型转换

隐式类型转换

自动进行数据类型转换

两种不同的数据类型（整数+浮点数）进行运算，较低数据类型（整数）会转换为较高数据类型（浮点数），以避免数据丢失

高低是描述数据精度的概念

num_int = 123
num_flo = 1.23
num_new = num_int + num_flo

print("datatype of num_int:", type(num_int))
print("datatype of num_flo:", type(num_flo))
print("Value of num_new:", num_new)
print("datatype of num_new:", type(num_new))

显式类型转换

将对象数据类型转换为所需数据类型，使用预定义函数来执行

num_int = 123
num_str = "456"

print("num_int 数据类型为:", type(num_int))
print("类型转换前，num_str 数据类型为:", type(num_str))
num_str = int(num_str)    # 强制转换为整型
print("类型转换后，num_str 数据类型为:", type(num_str))

num_sum = num_int + num_str
print("num_int 与 num_str 相加结果为:", num_sum)
print("sum 数据类型为:", type(num_sum))

函数	描述
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)	将一个整数转换为一个八进制字符串

推导式

独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体

if condition是可选内容

列表(list)推导式

[ out_exp_res for out_exp in input_list if condition ]
# out_exp_res：列表生成元素表达式，可以是有返回值的函数
# for out_exp in input_list：迭代 input_list 将out_exp 传入到 out_exp_res 表达式中
# if condition：条件语句，可以过滤列表中不符合条件的值

names = ['Bob', 'Tom', 'alice', 'Jerry', 'Wendy', 'Smith']
new_names = [name.upper()for name in names if len(name) > 3]
print(new_names)

字典(dict)推导式

{ key_expr: value_expr for value in collection if condition }
# key_expr: value_expr 键值对

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {key:len(key) for key in listdemo}
print(newdict)

集合(set)推导式

{ expression for item in Sequence if condition }

set = {i**2 for i in (2, 4, 6)}
print(set)

元组(tuple)推导式

元组推导式返回的是一个生成器对象

(expression for item in Sequence if condition )

a = (x for x in range(1, 10))
print(a)
# 使用 tuple() 函数，可以直接将生成器对象转换成元组
tuple(a)