本文档目标：掌握常见变量的基本操作及各变量间转换

变量定义

变量为存储在内存中的值，用于程序临时保存数据使用。

变量包括名称、值、变量类型、内存地址等信息

a_int = 1
#变量赋值，python中变量不需要定义
#变量名称建议使用多个小写单词并以_连接
#变量名称不能与方法、关键字重复。比如不能命名为int，否则将导致使用int()时报错

print(a_int)
#打印变量的值

print(type(a_int))
#打印变量类型

print(id(a_int))
#打印变量的内存地址

变量输入输出

>>> a=input("input a number:")
input a number:123
#用input()函数获取输入的变量，可以可添加输入提醒

>>> print(a,type(a))
123 <class 'str'>
#输出使用print()
#所有的输入都是str,若程序需要的是其他类型的则需要进行转换

数字类型变量

主要介绍可用于存储数字的五种数据类型及这五种数据类型之间相互转换

整数型(int)、浮点型(float)、复数(complex)、字符串(str)与字节串(bytes)

1 赋值

>>> a_int=-12
>>> print(a_int,type(a_int),id(a_int))
-12 <class 'int'> 139792076681936
#int型赋值,赋值时变量名不能命名为int，否则将在后续演示调用int()时报错

>>> a_float=-12.9
>>> print(a_float,type(a_float),id(a_float))
-12.9 <class 'float'> 139792100565424
#float型赋值

>>> a_bytes=b'-2'
>>> print(a_bytes,type(a_bytes),id(a_bytes))
b'-2' <class 'bytes'> 139792076676392
#bytes型赋值
#bytes型支持保存字符串、数字、图片、音频等信息，这边为方便演示转换以-2举例

>>> a_complex=1+2j
>>> print(a_complex,type(a_complex),id(a_complex))
(1+2j) <class 'complex'> 2150393716528
#complex型赋值

>>> a_str='-12.9'
>>> print(a_str,type(a_str),id(a_str))
-12.9 <class 'str'> 2150395477272
#str型赋值，可采用如下四种方式赋值:'值'、‘’‘值’‘’、“值”、“”“值”“”

2 数字类型互相转换

	int	float	str	bytes	complex
int		float(a_int)	str(a_int)	a_int.to_bytes(4, byteorder='little', signed=True)	complex(a_int)
float	int(a_float)		str(a_float)	不支持	complex(a.float)
str	int(a_str)	float(a_str)		a_str.encode()	complex(a_str)
bytes	int(a_bytes)	float(a_bytes)	a_bytes.decode()		不支持
complex	int(a_complex.real)	a_complex.real	str(a_complex)	不支持

complex不能直接转为int和float，但是可以通过real函数提取出实数部分

2.1 int

支持转为int型的仅有float、str、bytes，其他类型均不支持

complex虽然不能直接转为int，但是可提取出实数部分转为int型

>>> print(a_float,int(a_float),type(a_float))
-12.9 -12 <class 'float'>
#float-->int,会去掉小数点及后面的数值，仅保留整数部分

>>> print(b_str,type(b_str),int(b_str),type(int(b_str)))
-12 <class 'str'> -12 <class 'int'>
#str-->int,若字符串中有数字（0-9）和正负号（+/-）以外的字符，就会报错(包括小数点)

>>> print(a_bytes,int(a_bytes),type(int(a_bytes)))
b'-2' -2 <class 'int'>
#bytes-->int,若字节串中有数字（0-9）和正负号（+/-）以外的字符，就会报错(包括小数点)

>>> print(a_complex,int(a_complex.real),type(int(a_complex.real)))
(1+2j) 1 <class 'int'>
#complex-->int,由于直接舍弃虚数部分，不能认为是转换，仅适用于特定场合下。
#虚部获取可用a_complex.imag

2.2 float

支持转为float型的仅有int、str、bytes，其他类型均不支持

complex虽然不能直接转为floaat，但是可提取出实数部分转为float型

>>> print(a_int,float(a_int),type(float(a_int)))
-12 -12.0 <class 'float'>
#int-->float,会自动添加一位小数

>>> print(a_str,float(a_str),type(float(a_str)))
-012.1 -12.1 <class 'float'>
#str-->float,若字符串中有数字（0-9）、小数点(.)和正负号（+/-）以外的字符，就会报错

>>> print(a_bytes,float(a_bytes),type(float(a_bytes)))
b'-2' -2.0 <class 'float'>
#bytes-->float,若字节串中有数字（0-9）、小数点(.)和正负号（+/-）以外的字符，就会报错

>>> print(a_bytes,str(a_bytes),type(str(a_bytes)))
b'hello world' b'hello world' <class 'str'>
>>> print(a_bytes,str(a_bytes,encoding='utf-8'),type(str(a_bytes,encoding='utf-8')))
b'hello world' hello world <class 'str'>
>>> print(a_bytes,str(a_bytes.decode()),type(str(a_bytes.decode())))
b'hello world' hello world <class 'str'>
#bytes-->str，直接使用str()将进行完全转换;若使用bytes.decode()或str()指定encoding将转换为实际的值

>>> print(a_complex,a_complex.real,type(a_complex.real))
(1+2j) 1.0 <class 'float'>
#complex-->float,由于直接舍弃虚数部分，不能认为是转换，仅适用于特定场合下。
#虚部获取可用a_complex.imag

2.3 str

任意对象都能转成字符串

>>> print(a_int,str(a_int),type(str(a_int)))
-12 -12 <class 'str'>
#int-->str,直接完全转换

>>> print(a_float,str(a_float),type(str(a_float)))
-12.9 -12.9 <class 'str'>
#float-->str，转成字符串会去掉末尾为0的小数部分

>>> a_complex=complex(1,2)
>>> print(a_complex,str(a_complex),type(str(a_complex)))
(1+2j) (1+2j) <class 'str'>
#complex-->str,会先转成标准complex表达式，再转成字符串

2.4 bytes

支持int、str转为bytes

>>> print(a_int,a_int.to_bytes(2,byteorder='little',signed=True),type(a_int.to_bytes(2,byteorder='little',signed=True)))
-12 b'\xf4\xff' <class 'bytes'>
#int-->bytes，2为字节串长度;byteorder为字节顺序;signed表示是否使用补码,若该值为False且int为负数将报错

>>> a_str='中国'
>>> print(a_str,a_str.encode(),type(a_str.encode()))
中国 b'\xe4\xb8\xad\xe5\x9b\xbd' <class 'bytes'>
>>> print(a_str,bytes(a_str,encoding='utf-8'),type(bytes(a_str,encoding='utf-8')))
中国 b'\xe4\xb8\xad\xe5\x9b\xbd' <class 'bytes'>
#str-->bytes，支持以上两种方式

2.5 complex

仅支持int、float、str转换为complex类型

>>> print(a_int,complex(a_int),type(complex(a_int)))
-12 (-12+0j) <class 'complex'>
#int-->complex，自动添加虚部并以0j表示

>>> print(a_float,complex(a_float),type(complex(a_float)))
-12.9 (-12.9+0j) <class 'complex'>
#float-->complex，自动添加虚部并以0j表示

>>> print(a_str,complex(a_str),type(complex(a_str)))
-012.1 (-12.1+0j) <class 'complex'>
>>> print(a_str,complex(a_str),type(complex(a_str)))
-1+2j (-1+2j) <class 'complex'>
#str-->complex，分两种情况：1、能转成int、flost，先转换成int或float再转成complex；2、符合complex表达式(第二个符号前后不能空格)直接转成complex

序列类型变量

序列类型主要包括列表(list)、元组(tuple)、字典(dict)、集合(set)

本章节主要介绍这四种序列类型的差异及互相转换

1 序列类型比较

1.2 元素比较

	内容	是否可修改	是否有序	是否可重复
list	任意	是	是	是
tuple	任意	否	是	是
dict	键值对	是	否	否
set	任意	是	否	否

1.2 变量定义

	直接赋值	赋空值	函数赋值
list	a_list=['1','a']	b_list=[]	c_list=list(seq)
tuple	a_tuple=(1,2,'3')	b_tuple=()	c_tuple=tuple(seq)
dict	a_dict={'name':'lin'}	b_dict={}	c_dict=dict.fromkeys(seq,val=None) #val=None用于设置默认值，默认为None
set	a_set={1,2,3}	b_set=set()	c_set=set(seq) d_set=forzenset(set) #forzenset用于创建固定集合，该类型集合不可修改

备注1：seq指序列类型，包括list、tuple、dict、set、str（字符串可以认为是特殊的元组）

2 基本操作(增删改查)

2.1 list

========增=========
a_list.append(3)
#在末尾追加
a_list.insert(3,'a')
#在指定位置插入
a_list.extend(b_list)
#将列表b_list中的元素添加到a_list后面

========删=========
a_list.remove(3)
#删除第一个匹配项，若元素不存在则报错
a_list.pop()
#删除最后一个元素并返回该元素

========改=========
a_list[2]=12
#单元素修改
a_list[2:3]=[12,13]
#多元素修改
a_list.sor(reverse=True)
#a_list进行排序处理，不返回内容，reverse设置为True表示倒序，False为正序
sorted(a_list,reverse=False)
#对a_list进行排序处理并返回结果，reverse设置为True表示倒序，False为正序

========查=========
a_list.index(1)
#获取指定元素第一次出现的位置
1 in a_list
#判断指定元素是否在a_list中
a_list.count(3)
#计算a_list中指定元素出现的次数

2.2 tuple

========增=========
不可新增

========删=========
del a_tuple
#删除整个元组，而非删除元组中元素

========改=========
#不可修改

========查=========
a_tuple[0]
#获取指定元素
a_tuple[1:3]
#获取指定范围的元素，获取的结果依旧是元组
max(a_tuple)
#获取元组中的最大值，只支持同类型比较
min(a_tuple)
#获取元组中的最小值，只支持同类型比较
1 in a_tuple
#判断元素是否在元组中

2.3 dict

========增=========
a_dict.setdefault('name','lin')
#若键不存在字典中，则新增键值对；否则返回对应的值
a_dict.update(b_dict)
#将字典b_dict中的键值对添加到a_dict中

========删=========
a_dict.pop(3)
#删除指定键值对并返回；若不存在则报错
a_dict.popitem()
#随机删除键值对，并返回
del a_dict[3]
#删除指定键值对无返回；若不存在则报错
a_dict.clear
#清空字典中所有元素

========改=========
dict['name']='Lin' 
#修改某个键值对的值

========查=========
dict1['name'] 
#查询某个键值对的值，若不存在则报错
dict2.get('name',0)
#查询某个键值对的值，若不存在则返回默认值
’name‘ in dict3.keys()
#查询某个键是否存在

2.4 set

========增=========
a_set.add('1')
#添加元素
a_set.update(b_set)
#将集合b_set中的元素添加到集合a_set

========删=========
a_set.discard(6)
#删除指定元素，元素不存在不报错
a_set.remove(6)
#删除指定元素，元素不存在则报错
a_set.pop()
#随机删除一个元素并返回
a_set.clear()
#清空集合

========改=========
a_set.intersection_update(b_set)
#将a_set与b_set的并集赋值给a_set
a_set.difference_update(b_set)
#将a_set与b_set的差集赋值给a_set
set1.symmetric_difference_update(set2)
#获取a_set与b_set的对称差集赋值给a_set

========查=========
x in a_set
#判断元素是否在集合a_set中
a_set.issubset(b_set)
#判断a_set是否是b_set的子集，超集则是issuperset
a_set.union(b_set)
#获取a_set和b_set的并集，不影响a_set与b_set，类似的还有differenct(差)、intersection(交)、symmetric_defference(对称差)

3 序列类型转换

	str	list	tuple	dict	set
str		list(a_str)	tuple(a_str)	ast.literal_eval(a_str)	set(a_str)
list	str(a_list) a_str.join(a_list)		tuple(a_list)	dict(zip(a_list,b_list))	set(a_list)
tuple	str(a_tuple) a_str.join(a_tuple)	list(a_tuple)		dict(zip(a_tuple,b_tuple))	set(a_tuple)
dict	str(a_dict) a_str.join(a_dict)	list(a_dict)	tuple(a_dict)		set(a_dict)
set	str(a_list) a_str.join(a_dict)	list(a_set)	tuple(a_set)	dict(zip(a_set,b_set))

a_str.join(seq),只适用于元素为字符串，a_str用于保存拼接之后的字符串

3.1 str

>>> print(a_list,type(a_list),str(a_list),type(str(a_list)))
[1, 2, 3, 4, 5] <class 'list'> [1, 2, 3, 4, 5] <class 'str'>
#seq->str:会先将值转为标准的seq表达式(包括list、tuple、dict、set)，然后直接转为字符串

>>> a_list
['1', '2', '3']
>>> a_str=''
>>> a_str.join(a_list)
'123'
#a_str.join(seq):当元素为字符串时可以将元素合并并赋值给a_str

3.2 list

>>> print(a_str,list(a_str))
12345 ['1', '2', '3', '4', '5']
#str->list:将每个字符转为list中的元素

>>> list(b'hello')
[104, 101, 108, 108, 111]
#bytes->list:取每个字节的ASCII十进制值并组合成列表。

>>> print(a_tuple,list(a_tuple))
(1, 2, 3) [1, 2, 3]
#tuple->list:元组中每个元素转换为列表中的元素

>>> print(a_dict,list(a_dict))
{'name': 'lin', 'sex': 'man'} ['name', 'sex']
#dict->list:取字典中每个键值对的键做为列表中的元素

>>> a_set={1,2,3,4,4,4,4,4}
>>> print(a_set,list(a_set))
{1, 2, 3, 4} [1, 2, 3, 4]
#set->list:先去重再转成列表。由于集合不可重复，去重在赋值时已完成

3.3 tuple

>>> print(a_str,tuple(a_str))
123456 ('1', '2', '3', '4', '5', '6')
#str->tuple:将每个字符转换成元组中的元素

>>> print(a_list,tuple(a_list))
['1', '2', '3'] ('1', '2', '3')
#list->tuple:将list中的元组转成元组中的元素

>>> print(a_dict,tuple(a_dict))
{'name': 'lin', 'sex': 'man'} ('name', 'sex')
#dict->tuple:将字典键值对中的键转成元组中的元素

>>> a_set={1,2,3,4,4,4,4,4}
>>> print(a_set,tuple(a_set))
{1, 2, 3, 4} (1, 2, 3, 4)
set->tuple:集合去重之后转成元组中的元素。由于集合不可重复，去重在赋值时已完成

3.4 dict

>>> a_str="{'name':'lin','age':12}"
>>> import ast
>>> ast.literal_eval(a_str)
{'name': 'lin', 'age': 12}
#str->dict:若使用json需确保所有的键值都用单引号包围、若使用eval则会执行任何符合语法的表达式字符串，存在安全隐患

>>> print(a_list,b_list,dict(zip(a_list,b_list)))
['name', 'age'] ['lin', 12, 'man'] {'name': 'lin', 'age': 12}
#list->dict：合并两组列表作为字典；第一组为键，第二组为值；若键重复则后面的覆盖前面的。
    若list中的元素为两个元素的list，则可以直接使用dict(list)进行转换
    
>>> print(a_tuple,b_tuple,dict(zip(a_tuple,b_tuple)))
('name', 'age') ('lin', 12, 'man') {'name': 'lin', 'age': 12}   
tuple->dict#合并两组元组作为字典；第一组为键，第二组为值；若键重复则后面的覆盖前面的。
        若元组中的元素为两个元素的元组，则可以直接使用dict(tp)进行转换
   
>>> print(a_set,b_set,dict(zip(a_set,b_set)))
{'name', 'age'} {12, 'lin', 'man'} {'name': 12, 'age': 'lin'}
#set->dict:合并两个集合作为字典，第一组为键，第二组为值

3.5 set

>>> print(a_str,set(a_str))
123133 {'1', '2', '3'}
#str->set:先将字符切割成元组，然后去重转换为集合

>>> print(a_list,set(a_list))
[1, 2, 1, 2, 1, 2] {1, 2}
#list->set:先对列表去重，然后转换为集合

>>> print(a_tuple,set(a_tuple))
(1, 2, 1, 2, 1, 2) {1, 2}
#tuple->set:先对元组去重，然后转换为集合

>>> print(a_dict,set(a_dict))
{'name': 'lin', 'xb': 'boy'} {'name', 'xb'}
#dict->set:取字典的键名组合成集合