Python 基础

0x01 Python 的概念

历史

Python 语言发明于1989年，1991年公开发行。Python 的名字来源于英国喜剧团 MontyPython,原因是 Python的创始人 Guido van Rossum（荷兰人）是该剧团的粉丝。Python 是初学者学习编程的最好语言，是一种不受局限、跨平台的开源编程语言，功能强大、易写易读，能在 Windows、Mac 和 Linux 等平台上运行。
Python 和 C++、Java 一样是一门高级编程语言，也被认为是一门解释型语言，将高级语言的一条语句翻泽为机器语言，然后运行。且解释器发现错误，程序会抛出异常或立即终止。

Python 的特点

1、简单、易学
Python 的设计哲学是优雅、明确、简单。Python 极其容易上手，因为 Python 有极其简单的语法，使你能够专注于解决问题而不是去搞明白语言本身。
2、免费、开源
Python 是 Free/Libre and Open Source(FLOSS，自由/开放源码软件)之一。使用者可以自由地发布这个软件的拷贝、阅读、使用和改动它的源代码或将其中一部分用于新的自由软件中。
3、高级解释性语言
Python 语言是一门高级编程语言， 程序员在开发时无需考虑底层细节。Python 解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。这使得 Python 程序更加易于移植。
4、可移植性
Python 可在 Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2 和 android平台等平台上运行。
5、面向对象
Python 既支持像C语言一样面向过程的编程，也支持如 C++、JAVA 语言一样面向对象的编程。
6、可扩展性
Python 提供丰富的 API、模块和工具，以便程序员轻松使用 C、C++语言来编写扩充模块。
7、可嵌入性
Python 程序可以嵌入到 C/C++/Matlab 程序，从而向用户提供脚本。
8、丰富的库
Python 标准库庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XMLRPC、HTML、WAV 文件、密码系统、GUI (图形用户界面)、Tk和其他与系统有关的操作。除了标准库以外，还有许多其他高质量第三方库，如TeoroPTorch Pchatrs Kens Tised和 OpunCV 图像库等。
9、规范的代码
Python 采用强制缩进的方式使得代码具有较好的可读性。
Python 语言广泛应用于科学计算、自然语言处理、图形图像处理、游戏开发、系统管理、WEB应用、Web安全等。许多大型网站就是用 Python 开发的，如 YouTube、Instagram。很多大公司的应用，包括 Google、Yahoo 等，甚至 NASA (美国航空航天局)都大量使用 Python。Python 受关注程度逐年上升。

0x02 Python 环境安装

Pycharm安装包：
链接：https://pan.quark.cn/s/51629d91ae3a
提取码：tS8v

交互式运行 Python

win + R 输入 cmd：

使用Pycharm

创建项目：


创建成功之后的结构：

创建一个文件并输出：hello world！

0x03 Python 基础语法

标识符

同其他语言一致，规则：
1.数字，字母，下划线组成，不能以数字开头
2.严格区分大小写
3.不能使用关键字作为标识符
4.见名知意

关键字

关键字是 python 中内置的标识符,我们自己定义的标识符不能和这些关键字有重复。关键字是由语言本身定义好的有特殊含义的代码元素，在 Python 中只有33个关键字：

变量

python 属于弱数据类型语言，声明变量时不用写数据类型。python 的编程规范每一句代码之后不用加分号，当然加来也不会报错。同其他语言一样,变量主要是用来存储数据的。

#声明编码集，该注释语句必须被放在文件的第1行或第2行才有效
# coding=utf-8
#声明变量并赋值
name='jack'
age=18
address="北京"
#输出变量
print(name)
print(age)
print(address)

模块

Python 的模块，就是一个文件,模块是保存文件的最小单位,在模块中可以声明：变量，函数，类等代码。如果一个文件想要调用另一个文件中的变量或者其他代码，则需要引入模块（可以理解为：PHP的文件包含）主要有如下三种方式：

#导入m2模块的所有代码元素，访问m2模块的x元素
import m2
print(m2.x)
#导入m2模块的所有代码元素，访问m2模块的x元素并重命名为x2
from m2 import x as x2 #
print(x2)

基本数据类型

在Python中所有的数据类型都是类，每个数据值都是类的"实例"。
在Python中有6种主要的内置数据类型：数字、字符串、列表[]、元组、集合和字典。
列表、元组、集合和字典可以容纳多项数据。
数字类型有4中：整数、浮点、复数、布尔

整数类型

>>> 28   #十进制表示方式
28
>>> type(28)   #type()函数返回数据的类型
<class 'int'>
>>> 0b11100   #二进制表示方式，以阿拉伯数字0与英文字母B(b)作为前缀
28
>>> 0o34   #八进制表示方式，以阿拉伯数字0与英文字母O(o)作为前缀
28
>>> 0x1c   #十六进制表示方式，以阿拉伯数字0与英文字母X(x)作为前缀
28

浮点类型

>>> 1.0   #采用小数表示浮点数据
1.0
>>> type(1.0)
<class 'float'>
>>> 3.36e2   #使用科学计数法表示浮点数据，在科学计数法中会使用E(e)表示10的指数
336.0
>>> 1.56e-2
0.0156
>>> .56e-2
0.0056

复数类型

整数和浮点数（小数）在数学中被统称为实数。与实数对应的是复数，复数在数学中被表示为：a+bi，其中a被称为实部，b被称为虚部，i被称为虚数单位。

>>> 1+2j   #1+2j表示实部为1、虚部为2的复数
(1+2j)
>>> (1+2j)+(1+2j)   #实现了两个复数(1+2j)的相加
(2+4j)
>>> c=3+4j
>>> type(c)   #复数类型为complex
<class 'complex'>

布尔类型

Python中的布尔类型是bool类，是int的子类，只有两个值：True 和 False，任何非空和非0都是 True，bool()函数主要用于转换。

>>> bool(0)   #整数0被转换为False
False
>>> bool(2)   #其他非零整数被转换为True
True
>>> bool('')   #空字符串被转换为False
False
>>> bool('a')   #其他非空字符串被转换为True
True
>>> bool([])   #空列表被转换为False
False
>>> bool({})   #空字典被转换为False
False

数据类型转换

很多数字类型的数据都可以被转换为布尔值，Python 中的很多数据类型都可以相互转换。在 Python 的数字类型中，除复数外，其他三种数字类型如整数、浮点和布尔都可以相互转换，分为隐式类型的转换和显式类型的转换。
隐式转换：数字之间可以进行数学计算，在进行数学计算时若数字类型不同，则会发生隐式类型的转换。浮点 > 整数 > 布尔。

>>> a=1+True   #布尔值被转换为整数
>>> a
2
>>> a=1.0+1   #整数1被转换为浮点数
>>> a
2.0
>>> a=1.0+True   #布尔值True被转换为浮点数
>>> a
2.0
>>> a=1.0+1+True   #整数1和布尔值都被转换为浮点数
>>> a
3.0
>>> a=1.0+1+False
>>> a
2.0

显示转换：利用对应的函数来进行转换。

>>> a=int(1.0)+1   #int(1.0)被转换为整数1
>>> a
2
>>> int(False)   #布尔数值False使用int()函数返回0
0
>>> int(True)   #布尔数值True使用int()函数返回1
1
>>> int(0.6)   #浮点数值使用int()函数会截掉小鼠部分
0
>>> float(5)   #整数值使用float()函数会加上小数部分的(.0)
5.0
>>> float(False)
0.0
>>> float(True)
1.0

运算符

有了数据，我们就可以通过运算符把它们连接起来，形成表达式，进而通过表达式进行运算，最后返回一个结果。

算数运算符

>>> a=1
>>> a
1
>>> -a
-1
>>> 1+1
2
>>> 2-1
1
>>> 2*3
6
>>> 3/2
1.5
>>> 3%2
1
>>> 3//2
1
>>> -3//2
-2
>>> 2**3
8

比较运算符

>>> a=1
>>> b=2
>>> a>b
False
>>> a<b
True
>>> 1.0==1   #浮点数与整数都可以进行比较
True
>>> 1.0!=1
False

字符串的比较：即逐一比较字符Unicode编码的大小，如果两个字符串的第1个字符不能比较出大小，则比较两个字符串的第2个字符，直到比较有了结果才结束比较
比较列表大小，即逐一比较其中元素的大小，如果两个列表中的第1个元素不能比较出大小，则比较两个列表中的第2个元素，直到比较有了结果才结束比较。注意，在两个列表中元素类型要兼容。

>>> a=[]
>>> b=[2,1]
>>> a>b
False
>>> a=['2']
>>> a>b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'str' and 'int'

逻辑运算符

逻辑运算符用于对布尔型变量进行运算，其结果也是布尔型。
not ==> !
and ==> &&
or ==> ||

短路设计："逻辑与"和"逻辑或"在计算过程中只要结果确定，则不再计算后面的表达式，从而提高效率。
表达式1(False) and 表达式2(不再计算) ==> False
表达式1(True) and 表达式2(不再计算) ==> True

位运算

赋值运算符

运算符优先级

流程控制

分支语句

Python 中只有 if 分支，没有 switch 语句。
if 语法结构：

if 条件：   #以英文冒号结尾
	语句组   #缩进(在Python编程规范中推荐使用4个半角空格)

if-else 语法结构：

if 条件:   #以英文冒号结尾
	语句组1
else:
	语句组2   #缩进(在Python编程规范中推荐使用4个半角空格)

if-elif-else 语法结构：

if 条件1:
	语句组1
elif 条件2:
	语句组2
	...
elif 条件n:
	语句组n
else:
	语句组n+1

循环语句

while 语法结构：

while 循环条件:   #以英文冒号结尾
	循环体语句组   #缩进(在Python编程规范中推荐使用4个半角空格)
[else:   #中括号部分可以省略
	语句组]

else子语句是在循环体正常结束时才执行的语句，当循环被中断时不执行，当遇到break、return和有异常发生时都会中断循环。
for 语法结构：

for 变量 in 可迭代对象:
	循环体语句组
[else:
	语句组]

0x04 复杂数据类型-容器类数据

序列

序列（sequence）是一种可迭代的、元素有序的容器类型的数据。序列包括列表（list）、字符串（str）、元组（tuple）和字节序列（bytes）等。
列表：可以理解为数组，可以包含不同类型的数据，使用[]表示

序列的索引操作

我们主要是通过下标访问序列中的元素，下标运算符是跟在容器数据后的一对中括号（[]），中括号带有参数，对于序列类型的数据，这个参数就是元素的索引序号。

a='Hello World!'
b=a[0]
print(b)
print(max(a))
print(min(a))
#运行结果：H、r

加和乘操作

加(+)运算符可以将两个序列连接起来，乘(*)运算符可以将两个序列重复多次。
'Hello'*2 ==> 'HelloHello'
'Hello'+'World' ==> 'HelloWorld'

>>> a='Hello'
>>> a*2
'HelloHello'
>>> a+='World'
>>> a
'HelloWorld'

切片操作

序列的切片（Slicing）就是从序列中切分出小的子序列。切片运算符的语法形式为[start：end：step]。其中，start是开始索引，end是结束索引，step是步长（切片时获取的元素的间隔，可以为正整数，也可以为负整数）。切下的小切片包括start位置的元素，但不包括end位置的元素，start和end都可以省略。

a='123456789'
b=a[1:3]
print(b)
#输出23，下标从0开始，包前不包后

测试成员-是否包含

成员测试运算符有两个：in和not in，in用于测试是否包含某一个元素，not in用于测试是否不包含某一个元素。

>>> a='Hello'
>>> 'e' in a
True
>>> 'E' not in a
True

列表

列表（list）是一种可变序列类型，我们可以追加、插入、删除和替换列表中的元素。

创建列表

创建列表有两种方法。
1.list（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）。
2.[元素1，元素2，元素3，⋯]：指定具体的列表元素，元素之间以逗号分隔，列表元素需要使用中括号括起来。

list1=[1,2,3,4,5]
print(list1)
list2=list("PHP")
print(list2)
#输出结果：
[1, 2, 3, 4, 5]
['P', 'H', 'P']

列表追加

列表是可变的序列对象，列表可以追加元素。
1.在列表中追加单个元素时，可以使用列表的 append（x）方法。
2.在列表中追加多个元素时，可以使用加（+）运算符或列表的extend（t）方法。

list1=[1,2,3,4,5]
list1.append(100)
print(list1)
list2=[66,77]
list1.extend(list2)
print(list1)
list3=[88,99]
list1+=list3
print(list1)
#输出结果：
[1, 2, 3, 4, 5, 100]
[1, 2, 3, 4, 5, 100, 66, 77]
[1, 2, 3, 4, 5, 100, 66, 77, 88, 99]

列表插入

向列表中插入元素时，可以使用列表的list.insert（i，x）方法，其中，i指定list索引位置，x是要插入的元素。

列表替换

替换列表中的元素时，将列表下标索引元素放在赋值符号（=）的左边，进行赋值即可。

>>> list=[20,10,30,50]
>>> list[1]=80
>>> list
[20, 80, 30, 50]

列表删除

在列表中删除元素时，可使用列表的list.remove（x）方法，如果找到匹配的元素x，则删除该元素，如果找到多个匹配的元素，则只删除第一个匹配的元素。

>>> list=[20,10,80,50,30]
>>> list.remove(80)
>>> list
[20, 10, 50, 30]

元组

元组(tuple)是一种不可变序列类型。

创建元组

创建元组时有两种方法。
1.tuple（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）。

2.（元素1，元素2，元素3，⋯）：指定具体的元组元素，元素之间以逗号分隔。对于元组元素，可以使用小括号括起来，也可以省略小括号。

tuple1=tuple("Hello")
print(tuple1)
tuple2=(1,2,3,40)
print(tuple2)
#输出结果为：
('H', 'e', 'l', 'l', 'o')
(1, 2, 3, 40)

元组拆包

创建元组，并将多个数据放到元组中，这个过程被称为元组打包。与元组打包相反的操作是拆包，就是将元组中的元素取出，分别赋值给不同的变量。

stu=('jack',18,"四川成都")
stu_name,stu_age,stu_address=stu
print(stu_name)
print(stu_age)
print(stu_address)
#输出结果为：
jack
18
四川成都

注意： 元组中可以存放任意类型数据，应该是容器类型都可以存放任意数据，只是通常我们只存放相同类型

集合

集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。无序，就是没有下标，没有排序。

创建集合

我们可以通过以下两种方式创建集合。
1.set（iterable）函数：参数iterable是可迭代对象（字符串、列表、元组、集合和字典等）。
2.{元素1，元素2，元素3，⋯}：指定具体的集合元素，元素之间以逗号分隔。对于集合元素，需要使用大括号括起来。

set1=set("hello")
print(set1);
set2={10,20,30,40}
print(set2);
print(type(set2))
#输出结果为：
{'e', 'o', 'h', 'l'}
{40, 10, 20, 30}
<class 'set'>

修改集合

修改集合类似于修改列表，可以向其中插入和删除元素。修改可变集合有如下所示的常用方法。
1.add（elem）：添加元素，如果元素已经存在，则不能添加，不会抛出错误。
2.remove（elem）：删除元素，如果元素不存在，则抛出错误。
clear（）：清除集合。

names={"程咬金","貂蝉","吕布","曹操"}
print(names)
names.add("刘备")
print(names)
names.remove("貂蝉")
print(names)
names.clear()
print(names)
#输出结果为：
{'貂蝉', '吕布', '曹操', '程咬金'}
{'曹操', '貂蝉', '刘备', '吕布', '程咬金'}
{'曹操', '刘备', '吕布', '程咬金'}
set()

字典

字典（dict）是可迭代的、通过键（key）来访问元素的可变的容器类型的数据。字典由两部分视图构成：键视图和值视图。键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。

创建字典

我们可以通过以下两种方法创建字典。
1.dict（ ）函数。
2.{key1：value1，key2：value2，...，key_n：value_n}：指定具体的字典键值对，键值对之间以逗号分隔，最后用大括号括起来。

dict1=dict({101:"jack",102:"rose"})
print(dict1)
dict1=dict(((103,"lucy"),(104,"tom")))
print(dict1)
dict1=dict([(103,"lucy"),(104,"tom")])
print(dict1)
输出结果为：
{101: 'jack', 102: 'rose'}
{103: 'lucy', 104: 'tom'}
{103: 'lucy', 104: 'tom'}

修改字典

字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除。

dict1=dict({101:"jack",102:"rose"})
dict1[103]="lucy"
print(dict1)
dict1[102]="Tom"
print(dict1)
dict1.pop(102)
print(dict1)
输出结果为：
{101: 'jack', 102: 'rose', 103: 'lucy'}
{101: 'jack', 102: 'Tom', 103: 'lucy'}
{101: 'jack', 103: 'lucy'}

字典视图

我们可以通过字典中的三种方法访问字典视图。
1.items（ ）：返回字典的所有键值对视图。
2.keys（ ）：返回字典键视图。
3.values（ ）：返回字典值视图。

dict1=dict({101:"jack",102:"rose"})
print(dict1.items())
print(dict1.keys())
print(dict1.values())
输出结果为：
dict_items([(101, 'jack'), (102, 'rose')])
dict_keys([101, 102])
dict_values(['jack', 'rose'])

遍历字典

s_dict={102:"张三",105:"李四",109:"王五"}
print('---遍历键---')
for s_id in s_dict.keys():
    print('学号:'+str(s_id))
print('---遍历值---')
for s_name in s_dict.values():
    print('学生:'+s_name)
print('---遍历键:值---')
for s_name in s_dict.items():
    print('学号:{0} - 学生:{1}'.format(s_id,s_name))
#输出结果为：
---遍历键---
学号:102
学号:105
学号:109
---遍历值---
学生:张三
学生:李四
学生:王五
---遍历键:值---
学号:109 - 学生:(102, '张三')
学号:109 - 学生:(105, '李四')
学号:109 - 学生:(109, '王五'

字符串

字符串有三种表示方式：普通字符串、原始字符串和长字符串。
普通字符串指用单引号或双引号括起来的字符串。

>>> 'hello'
'hello'
>>> "hello"
'hello'
>>> s='\u0048\u0065\u006c\u006c\u006f'
>>> s
'Hello'

普通字符串前加上r，就是原始字符串，原始字符串不会去解析里面的特殊字符。

str1=r'I Love\n Python!'
print(str1)
#输出结果为:
I Love\n Python!

如果要使用字符串表示一篇文章，其中包含了换行、缩进等排版字符，则可以使用长字符串表示。对于长字符串，要使用三个单引号（'''）或三个双引号（＂＂＂）括起来。

str3 = '''
           静夜思
    床前明月光，疑是地上霜。
    举头望明月，低头思故乡。
'''
str4 = """
             赠汪伦
    李白乘舟将欲行，忽闻岸上踏歌声。
    桃花潭水深千尺，不及汪伦送我情。
"""

数字与字符串的转换

字符串转数字：将字符串转换为数字，可以使用int（ ）和float（ ）实现，如果成功则返回数字，否则引发异常。在默认情况下，int（ ）函数都将字符串参数当作十进制数字进行转换，所以int（'AB'）会失败。int（ ）函数也可以指定基数（进制）

>>> int("80")
80
>>> int("AB")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'AB'
>>> int("AB",16)   #指定按照16进制转换"AB"
171

数字转字符串：将数字转换为字符串，可以使用str（ ）函数，str（ ）函数可以将很多类型的数据都转换为字符串。

>>> str(123)
'123'
>>> str(True)
'True'

格式化字符串

要想将表达式的计算结果插入字符串中，则需要用到占位符。对于占位符，使用一对大括号（{}）表示。在占位符中可以有参数序号，序号从0开始。序号0被format()方法中的第1个参数替换；序号1被format()方法中的第2个参数替换，以此类推。

>>> i=32
>>> s='i*i='+str(i*i)
>>> s
'i*i=1024'
>>> s='i*i={}'.format(i*i)   #{}字符串占位符被format()方法中的参数替换
>>> s
'i*i=1024'
>>> s='{0}*{0}={1}'.format(i,i*i)
>>> s
'32*32=1024'
>>> s='{p1}*{p1}={p2}'.format(p1=i,p2=i*i)   #在占位符中可以有参数名，p1和p2是format()方法中设置的参数名，可以根据参数名替换占位符
>>> s
'32*32=1024'

格式化控制符：在占位符中还可以有格式化控制符，对字符串的格式进行更加精准的控制。字符串的格式化控制符及其说明如下表所示。格式化控制符位于占位符索引或占位符名字的后面，之间用冒号分隔，语法：{参数序号：格式控制符}或{参数名：格式控制符}。

money=5834.5678
name='Tony'
print('姓名:{0:s}，年龄:{1:d}，工资:{2:f}元'.format(name,20,money))
输出结果为：
姓名:Tony，年龄:20，工资:5834.567800元

查找字符串

字符串的find()方法用于查找子字符串。该方法的语法为 str.find(sub[，start[，end]])。表示在索引start到end之间查找子字符串sub，如果找到，则返回最左端位置的索引；如果没有找到，则返回-1。

>>> s_str='Hello World'
>>> s_str.find('e')
1
>>> s_str.find('l',4)
9
>>> s_str.find('l',4,6)
-1

替换字符串

若想进行字符串替换，则可以使用replace（ ）方法替换匹配的子字符串，返回值是替换之后的字符串。该方法的语法为str.replace（old，new[，count]），表示：用new子字符串替换old子字符串。count参数指定了替换old子字符串的个数，如果count被省略，则替换所有old子字符串。

>>> text='AB CD EF GH IJ'
>>> text.replace(' ','|')
'AB|CD|EF|GH|IJ'

字符串分割

若想进行字符串分割，则可以使用split（ ）方法，按照子字符串来分割字符串，返回字符串列表对象。该方法的语法为str.split（sep=None，maxsplit=-1），表示：使用sep子字符串分割字符串str。maxsplit是最大分割次数，如果maxsplit被省略，则表示不限制分割次数。

>>> text='AB CD EF GH IJ'
>>> text.split(' ')
['AB', 'CD', 'EF', 'GH', 'IJ']
>>> text.split(' ',maxsplit=2)
['AB', 'CD', 'EF GH IJ']

函数

定义函数：

def 函数名(形式参数列表):
	函数体   #缩进，在Python中推荐采用4个半角空格
	return 返回值   #如果没有数据返回，则可以省略return语句

参数默认值：

def make_coffee(name="抹茶星冰乐"):
    print("制作了一杯{0}咖啡！".format(name))
make_coffee()
make_coffee("摩卡")
输出结果为：
制作了一杯抹茶星冰乐咖啡！
制作了一杯摩卡咖啡！

可变参数：Python中的函数可以定义接收不确定数量的参数。可变参数有两种，即在参数前加*或**。

#基于元组的可变参数(*)
def sum(*numbers):
    total = 0.0
    for number in numbers:
        total += number
    return total
print(sum(100.0,20.0,30.0))   #多个参数被组装成元组numbers
print(sum(30.0,80.0))
输出结果为：
150.0
110.0
#基于字典的可变参数(**)
def show_info(**info):
    for key,value in info.items():
        print('{0} - {1}'.format(key,value))
show_info(name='Tony',age=18,sex=True)
show_info(student_name='Tony',student_no='1000')
输出结果为：
name - Tony
age - 18
sex - True
student_name - Tony
student_no - 1000

函数中变量作用域：变量可以在模块中创建，作用域（变量的有效范围）是整个模块，被称为全局变量。变量也可以在函数中创建，在默认情况下作用域是整个函数，被称为局部变量。

x=20   #在模块中定义变量x，作用域是整个模块
def print_value():
    x=10   #在模块中定义变量x，作用域是整个函数，它会屏蔽模块变量x
    print("函数中x={0}".format(x))
print_value()
print("全局变量x={0}".format(x))
#输出结果为：
函数中x=10
全局变量x=20

全局变量：global

x=20
def print_value():
    global x   #将函数的x变量提升为全局变量
    x=10
    print("函数中x={0}".format(x))
print_value()
print("全局变量x={0}".format(x))
#输出结果为：
函数中x=10
全局变量x=10