Python中的变量不需要声明，每个变量使用前必须赋值，变量赋值后才会被创建，在Python中变量就是变量，它没有类型。我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值，等号（=）运算符左边是变量名，等号（=）运算符右边是存储在变量名中的值。例如：
integer = 100 #这是整数，整型变量
float = 100.0 #这是浮点数，浮点型变量
string = "这是字符串" #这是字符串，字符串变量 print(integer)
print(float)
print(string)
执行以上程序会输出以下结果：
100
100.0
这是字符串
多个变量赋值
Python中允许你同时为多个变量赋值。例如：
a=b=c=1
print(a)
print(b)
print(c)
执行以上程序会输出如下结果：
1
1
1
以上实例，创建一个整型对象，值为1，三个变量a,b,c被分配到相同的内存空间上。
也可以为多个对象指定多个变量。例如
a,b,c=1,2,3
print(a)
print(b)
print(c)
执行以上程序会输出如下结果：
1
2
3
以上实例，三个对象1,2,3分别分配给三个变量a,b,c。
标准数据类型
Python中有六个标准数据类型：
- Number(数字)
- String（字符串）
- List(列表)
- Tuple(元组)
- Sets(集合)
- Dictionary（字典）
Python的内置的type()函数可以用来查询变量所指的对象类型。例如
integer = 100
float = 100.0
string = "这是字符串" print(type(integer)) #整型变量
print(type(float)) #浮点型变量
print(type(string)) #字符串变量
执行以上程序会输出如下结果：
<class 'int'>
<class 'float'>
<class 'str'>
Number(数字)
在Python3中支持int，float，bool，complex（复数）。像大多数语言一样，数值类型的赋值和计算都是很直观的。
在Python2中是没有布尔型的，它用数字0表示False，用1表示True。到Python3中，把True和False定义成关键字了，但它们的值还是1和0，它们可以和数字相加。例如：
print(100+False) #False代表数字0
print(100+True) #True代表数字1
执行以上程序会输出如下结果：
101
100
Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
表达式的语法很直白： + , - , * , / , // , ** 。
并且，不同类型的数值在进行混合运算时，会将整数转换成浮点数进行运算。
举例如下：
print(1+2) #加法
print(2-1) #减法
print(2*3) #乘法
print(10/5) #除法，得到浮点类型结果
print(21//5) #整数除法返回向下取整后的结果
print(21%5) #返回除法的余数
print(2**3) #幂运算，即2的三次方
print(2*3.0) #不同类型的数值在进行混合运算时，会将整数转换成浮点数进行运算
执行以上程序会输出如下结果：
3
1
6
2.0
4
1
8
6.0
String（字符串）
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")括起来来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!'
var2 = "I don't know this person"
字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值,-1 为末尾字符。从头下标（包括索引值为头下标的字符）开始截取到尾下标（不包括索引值为尾下标的字符）。例如：
var = 'abcdefghijklnm'
print (var) # 输出字符串
print (var[4]) # 输出字符串第五个字符
print (var[-1]) # 输出最后一个字符
print (var[-2]) # 输出倒数第二个字符
print (var[0:-1]) # 输出第一个到最后一个（不包括最后一个）的所有字符
print (var[:4]) # 输出字符串第五个字符之前的所有字符
print (var[2:5]) # 输出从第三个开始到第五个（不包括第五个）的字符
print (var[2:]) # 输出从第三个开始的后的所有字符
print (var * 2) # 输出字符串两次
print (var + "TEST") # 连接字符串
执行以上程序会输出如下结果：
abcdefghijklnm
e
m
n
abcdefghijkln
abcd
cde
cdefghijklnm
abcdefghijklnmabcdefghijklnm
abcdefghijklnmTEST
Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。例如：
print ("abcd\
efg") # \ (在行尾时)续行符
#输出结果：abcdefg
print("abcdef\\g") # \\ 反斜杠符号 == "\"
#输出结果：abcdef\g
print("abcde\'f\'g") # \' 单引号
#输出结果： abcde'f'g
print("abcde\"f\"g") # \" 双引号
#输出结果： abcde"f"g
print("abcdef\bg") # \b 退格，删除\b的前一个字符
#输出结果：abcdeg
print("abcdef\000g") # \000 空
#输出结果：abcdef g
print("abcdef\ng") # \n
#换行 输出结果：abcdef
# g
print("abcdef\tg") # \t 横向制表符
#输出结果：abcdef g
print(r"abcde\n\t\''\"") # 字符串前面添加一个 r，表示原始字符串
#输出结果：abcde\n\t\''\"
关于Python字符串运算符：
var1="hello"
var2="python" print("var1+var2的输出结果为:",var1+var2) # + 字符串连接
print(var1*2) # * 重复输出字符串
print(var1[1]) # [] 通过索引获取字符串中字符
print(var1[1:3]) # [a:b] 截取字符串中的一部分 if "h" in var1 : # in 成员运算符 - 如果字符串中包含给定的字符返回 True
print(" h 存在变量var1中")
else :
print(" h 不存在变量var1中") if "o" not in var1 : #not in 成员运算符 - 如果字符串中不包含给定的字符返回 True
print(" o 不存在变量var1中")
else :
print(" o 存在变量var1中")
执行以上程序会输出如下结果：
var1+var2的输出结果为: hellopython
hellohello
e
el
h 存在变量var1中
o 存在变量var1中
List(列表)
List（列表）是Python中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中的元素数据类型可以不相同，它支持数字、字符串甚至可以包含列表（所谓嵌套）。
和字符串一样，列表也可以被索引和截取，第一个元素索引为0，第二个元素索引为1，一次类推。列表被截取后返回一个包含所需元素的新列表。
列表是写在方括号[]之间，用逗号分隔开的元素列表。创建一个列表，只要把逗号分隔开的数据用方括号括起来即可，例如：
list1=["first",1000,"a",5000]
list2=[1,2,3,4,5,6,7,8,9,10]
创建列表list1=["a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
创建列表list2=[9,2,5,1,3,6,7,8,4]
列表的主要操作如下：
list1.append("this is append")# append 在列表最后一个元素的后面 添加一个元素
print(list1)
#运行结果 ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","this is append"]
list1.insert(2,"b-c")# insert 第一个：要添加到位置索引，第二个：要添加的元素内容，添加内容到指定的索引位置
print(list1)
#运行结果：["a","b","b-c","c","d","e","f","g","h","i","j","k","l","m","n"]
list2=["this is extend1","this is extend2"]
list1.extend(list2) # extend 将列表list2直接扩展到列表list1中
#运行结果：list1.insert(2,"b-c")# insert 第一个：要添加到位置索引，第二个：要添加的元素内容，添加内容到指定的索引位置
print(list1)
#运行结果：["a","b","b-c","c","d","e","f","g","h","i","j","k","l","m","n","this is extend1","this is extend2"]
list1.remove("a")# remove 已知元素内容，根据元素内容进行删除
print(list1)
#运行结果：["b","c","d","e","f","g","h","i","j","k","l","m","n"]
var=list1.pop(0)# pop 会返回要删除的元素内容，已知元素索引，根据元素索引进行删除
print(var)
print(list1)
#运行结果a
#运行结果["b","c","d","e","f","g","h","i","j","k","l","m","n"]
del list1[0] # del 已知元素索引，根据元素索引进行删除
print(list1)
#运行结果["b","c","d","e","f","g","h","i","j","k","l","m","n"]
del list1 #从内存中删除list1列表
list1.clear() #清空列表元素
list1[0]="aa" #根据元素索引更改变元素内容更新列表
print(list1)
#运行结果：["aa","b","c","d","e","f","g","h","i","j","k","l","m","n"]
list1[1:5]=["bb","cc","dd","ee"]#根据切片找到要修改的元素，更新列表
print(list1)
#运行结果：["a","bb","cc","dd","ee","f","g","h","i","j","k","l","m","n"]
list2.reverse()# reverse 对列表元素进行倒序
print(list2)
#运行结果：[4, 8, 7, 6, 3, 1, 5, 2, 9]
list2.sort()# sort 按照大小顺序对列表进行排序更新（从小到大）
print(list2)
#运行结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
Tuple(元组)
Python 的元组与列表类似，不同之处在于元组的元素不能修改，不能更新，不能删除。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
元组中只包含一个元素时，需要在元素后面添加逗号。
元组与字符串类似，下标索引从0开始，可以进行截取、组合等。截取、组合的方法与list(列表)的方法一致。
Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示:
dic0 = {"key1" : "value1", "key2" :" value2" }
dic1={0:"a",1:"b",2:"c"}
dic={"name":"xiaoming","age":22,"sex":"man","hobby":["羽毛球","乒乓球","足球"]}
字典的操作方法主要有以下几种：
dic={"name":"xiaoming","age":22,"sex":"man","hobby":["羽毛球","乒乓球","足球"]}
print(dic["name"])# 读取字典中某个内容可以根据 [key(键)] 来进行查找，而不再是根据list中的索引
#运行结果：xiaoming
print(dic.get("name")) # .get("key") 也可以进行读取
# 运行结果：xiaoming
for i in dic: #直接for遍历字典，会取到字典中的所有(key)键
print(i,end="\t")
# 运行结果：sex hobby name age
print(dic.keys()) # .keys 将字典中的所有（key）键 以dict_keys的类型进行返回 可进行列表转换
#运行结果：dict_keys(['name', 'hobby', 'sex', 'age'])
print( dic.values()) # .values 将字典中的所有（values）值 以dict_values的类型进行返回 可进行列表转换
#运行结果：dict_values(['xiaoming', 22, 'man', ['羽毛球', '乒乓球', '足球']])
print(list(dic.keys())) # list(dic.keys) 将dict_keys类型转换成list类型进行使用
#运行结果：['name', 'hobby', 'sex', 'age']
print(dic.items()) # .items() 将字典的每个键值对以dict_items返回
#运行结果：dict_items([('hobby', ['羽毛球', '乒乓球', '足球']), ('name', 'xiaoming'), ('sex', 'man'), ('age', 22)])
dic["name2"]="xiaohong" #直接根据 key(键) 赋值，如果存在这个（key）键 则对它进行更新 否则则添加该键值对
print(dic) # 运行结果：{'name': 'xiaoming', 'hobby': ['羽毛球', '乒乓球', '足球'], 'name2': 'xiaohong', 'sex': 'man', 'age': 22}
dic.setdefault("name3","xiaoli")# .setdefault (key)键存在，不改动，返回字典中相对应的值(value)，(key)键不存在，在字典里增加新的 键值对，并返回相应的(value)值
print(dic)#运行结果：{'name3': 'xiaoli', 'hobby': ['羽毛球', '乒乓球', '足球'], 'age': 22, 'sex': 'man', 'name': 'xiaoming'}
dic.setdefault("name3","aaaaaaaax")
print(dic)#运行结果：{'name3': 'xiaoli', 'sex': 'man', 'hobby': ['羽毛球', '乒乓球', '足球'], 'name': 'xiaoming', 'age': 22}
var=dic.pop("name")# .pop 根据（key）键 删除 键值对 并且返回所删除的值（value）
print(var) #运行结果：xiaoming
print(dic) #运行结果：{'hobby': ['羽毛球', '乒乓球', '足球'], 'age': 22, 'sex': 'man'}
del dic["name"]# del 根据（key）键 删除 键值对
print(dic)#运行结果{'sex': 'man', 'hobby': ['羽毛球', '乒乓球', '足球'], 'age': 22}
dic.clear() #清空字典
del dic #从内存中删除整个字典
dic2={"name22":"xiaohong",}
dic.update(dic2)# update dic2中的 键值对 如果在dic中存在，则进行修改更新，如果不存在 则进行添加
print(dic)
#运行结果：{'sex': 'man', 'name22': 'xiaohong', 'age': 22, 'name': 'xiaoming', 'hobby': ['羽毛球', '乒乓球', '足球']}
print(sorted(dic))#对（key）键进行排序
#运行结果：['age', 'hobby', 'name', 'sex']
print(sorted(dic.items()))#对键值对进行排序
#运行结果：[('age', 22), ('hobby', ['羽毛球', '乒乓球', '足球']), ('name', 'xiaoming'), ('sex', 'man')]