python基础

                                Python 3

 

 一,PYTHON编程语言历史及特性:

 

Shell编程:在使用一些自动化的脚本时更方便!!

编程语言用户:  问题空间计算机:解决问

 

Python语言是一种面向对象,解释型计算机程序设计语言，能在内核上执行的标准的二进制文件。

 

代码起源：

机器代码-->微码编程-->高级语言控制语言:

 

胶水语言框架:web,django字节码:bytocode具有丰富的类和开发工具

,

 

 二: python编程语言初接触  

 

Python的实现:

Cpython原始,标准的实现方式

Jython用于与Java语言集成的实现

Ironpython用于与.NET框架集成的实现

 

Python性能优化工具:psycoPython语言的一个扩展模块,可以即时对程序进行专业的算法优化,可以在一定的程度上提高程序的执行速度,尤其是在程序中有大量循环操作时.目前开发工作已经停止,

 

由pypy所代替Pypy是用python实现的python解释器Python语言的动态编译器,是psyco的后继项目可以运行在linux的32位和64位,MACOSX和Windows32位平台中

 

Shed skinPython编译器,能够将python代码转换成优化的c++代码  编写,执行python代码:

 

1.交互式解释器直接启动python ,其显示信息取决于程序版本及操作系统等

[root@localhost ~]# python

Python 3.0 (default, Aug  4 2017, 00:39:18)

[GCC 4.8.5 20150623 (Red Hat 4.8.5-16)] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> print('hello,world')

hello,world

 

程序文件交互式模式下的程序执行完成后难以再次运行将编写的程序保存至文件(. py)中方便多次运行   

A.python的此类包含了一系列预编写好的程序文件称作”模块”   

B.能够直接运行的模块文件通常称作脚本(即程序的顶层文件) Python程序文件

 

Python程序文件：

 

1.

第一步：写入程序

#!/usr/bin/python

import platform

print platform,uname()

 

第一行为shebang,即执行脚本时通知内容要启动的解释器

第二行通过import 导入一个python模块platform

第三行打印platform 模块的Uname方法的执行结果  

 

第二步：给权限

 chmod +x oo.py

 

第三步：执行

 ./oo.py

 

 

 

2.

Python 中一切皆对象!!

Python 程序可以分解为模块，语句，表达式和对象

程序由模块构成

模块包含语句

语句包含表达式

表达式建立并处理对象

  A.表达式是“某事”，而语句是“做某事（即指令）”

例如：“3+4”是某事。而“print 3+4”则是做某事：

  B. 语句的特性：他们改变了事物。例如,赋值语句改变了变量，print语句改变了屏幕输出等

  

面向对象：

以指令为中心，由指令处理数据

    如何组织代码解决问题

面向过程：

   以数据为中心，所有的处理代码都围绕数据展开

   如何设计数据结构组织数据，并提供对此类数据所允许处理操作

 

二．准备python 环境：

 

默认2.7，可不用卸载

如果要想安装新版本：按照如下方法： 1，编译安装新版本至某特定路径 ：

  A.下载wget https://www.python.org/ftp/python/3.6.0/Python-3.6.0a1.tar.xz

  B.. 解压:tar xvf  Python-3.6.0a1.tar.xz

  C. 创建安装文件的路径mkdir /usr/local/python3

  D.  yum -y install gcc-c++  安装c环境

  E. 编译： ./configure --prefix=/usr/local/python3/

  F 安装： make

           Make install

           完毕

  G、创建新版本的软连接。

  1、修改旧版本

  mv /usr/bin/python /usr/bin/python_bak

2、创建新的软连接

ln -s /usr/local/python3/bin/python3 /usr/bin/python

3、检查python的版本

python -V

python-3.6.0

软连接创建成功

H、配置成功后，python3用不了，需进一步配置。添加至环境变量

1、PATH=$PATH:$HOME/bin:

2、PATH=$PATH:$HOME/bin:/usr/local/python3/bin

3、完成

这时python3就可以使用了。

三．Python 快速入门

程序=数据结构+算法

数据结构：

通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合，这些数据元素可以是数字或者字符，甚至可以是其他的数据结构

python的最基本数据结构是序列

序列中的每一个元素被分配一个序号--即元素的位置，也称为索引，索引从0开始编号

python包含6中内建的数据序列：列表，元组，字符串

unicode字符串，buffer对象和xrande对象

 

1，第一个python程序：

>>>Print(“hello,world”)

Print函数表示的是将“”内部的命令打印到屏幕上,

2，集成开发环境IDE (pycharm)

图形用户界面，代码编辑器（支持代码补全，自动缩进）

编辑器/解释器    调试器（断点/单步执行）

3. 新建项目：

1） 命名规则：

  项目名前面都以数字编号，随着知识点递增，编号递增

  Eg:01_python 基础，02_分支，03循环。。

每个项目下的文_xx_知识点 方式来命名

 其中xx是演练文件的序件名都有hm号

注意：

1，命名文件名时建议只使用小写字母，数字和下划线

2，文件名不能以数字开始

通过欢迎界面或者菜单file/new project可以新建项目，在其下新建python文件

注释：

注释的作用：在程序中对某些代码进行标注说明，增强代码的可读性

单行注释：以#开头，#右边的所有东西都被当做说明文字，而不是真正要执行的程序，只是起到说明作用

多行注释（块设备）：”””  三行注释中间的内容都是注释内容

                     ”””

算数运算符：

 

 

 

 

程序执行原理（科普）

01.计算机中的三大件                                       

1.CPU                                                        

中央处理器，是一块超大规模的集成电路

负责处理数据、计算

2.内存

临时存储数据（断电之后，数据会消失）

速度快

空间小

价格高

3.硬盘

永久存储数据

速度慢

空间大

价格便宜

 

1，程序运行之前，程序是保存在硬盘中的

2,，当要运行一个程序时

   操作系统会首先让cpu把程序复制到内存中

   cpu执行内存中的程序代码

程序要执行，首先要被加载到内存

 

程序是用来处理数据的，而变量是用来存储数据的

 

 

Python的关键要素：

a基本数据类型 b对象引用 c组合数据类型 d逻辑操作符 e控制流语句f算数操作符 g输入/输出 h函数的创建与调用

要素一：基本数据类型

任何程序语言都必须能够表示基本数据项

python中的基本数据类型有：

1. Integral类型：（python中只有整型）

 

整型：不可变类型  （python中变量可分为可变量类型和不可变量类型）

   

   布尔型：true，false (不加引号)

Eg: bool(100)

    True

    Bool(0)

    False

   Bool([])

   False

   Bool([0])

   True

  非0非空的都是true

  

   （在Python中所有的字符串都需要用单双引号引起来，数值无需引号）

Eg  :

>>> num = 3  (3在python中被保存为对象，而且这个数值不可以被修改)

>>> id(num) （内置函数id ,查看num）

9306240  

>>> num =1  （ 这是定义的那个变量所保存的那个值）

>>> id(num)

9306176  （这是定义的那个变量所保存的那个值所引用的对象在内存中的地址）

所以 3,1，都没有发生改变只是，num这个变量他所指向的内存空间的指向发生了改变

 

Eg:                 eg

            

 

2.浮点类型：

 在python中只有单精度

Eg:

>>> type(1)

<class 'int'>

>>> type(1.1)

<class 'float'>

>>> type(1.11111)

<class 'float'>

 

 

 

3.字符串：三种情况

A. 关于字符串的出现，必须是成对出现

 

eg: ‘let’s go’  错误

   “let’s go” 或者 ‘let\’s go’

B.  “””

   “”” 中间是注释部分

 

C. 打印目录

>>>print(“c:\\ north\\tmp”)     中间多余的符号是转义的意思

C:\north\tmp

 

D.回文

Abccba   对称式

 

E:字符串的基本运算

 

字符串的拼接：

Eg: “today is” + “a good day”

     Today is a good day

Eg: “hello”*3

Hello hello hello

 

字符串的格式化问题

>>>age =20

>>>name=”bob”

>>> print (“{0} is {1} years old”. Format (age,name))

20 is bob years old

==print (“{} is {} years old”. .....)

 

字符转化问题：

>>>a=123.1

>>>b=int(a)

>>>b

123   强制定义为整型

 

转义字符：

\n: 换行

 \t ：tab

\r：回车  

   

 

 

要素2：对象引用（变量）

 

1.python将所有数据存为内存对象

   .python中，变量事实上是指向内存对象的引用

 

2 动态类型：在任何时刻，只要需要，某个对象引用都可以重新引用一个不同的        对象（可以是不同的数据类型）

 

3.内建函数type（）用于返回给定数据项的数据类型

 

4.“=”用于将变量名与内存中的某对象绑定：如果对象事先存在，就直接进行 .   绑定：否则，则由“=”创建引用的对象

 

5.变量命令规则

  只能包含字母，数字和下划线，且不能以数字开头

   区分字母大小写

   禁止使用保留字 （python2和python3的保留字由所不同）（就是系统中的关键字 如：IF）

6.命令惯例

   以单一下划线开变量名（_x）不会被from module import *语句导入

   前后有下划线的变量名（_x_）是系统定义的变量名，对python解释器有特殊意义

   以两个下划线开头但结尾没有下划线的变量名（__x）是类的本地变量

   交互模式下，变量名“_”用于保存最后表达式的结果

  

2.1 关键字

关键字就是在python内部已经使用的标识符

关键字具有特殊功能和含义

开发者不予许定义和关键字相同的名字的标识符

 

通过以下命令可以查看python中的关键字

Import keyword

Print(keyword.kwlist)

Import 关键字可以导入一个“工具包”

Eg: import keyword
print(keyword.kwlist)

表示列出所有系统上已经命名的变量名

 

02.变量的命名规则：

 

1.在定义变量时，为了保证代码格式。=的左右应该各保留一个空格

2.在python中，如果变量名需要二个或者多个单词组成时，可以按照以下方式命名

A.每个单词都使用小写字母

      单词与单词之间使用_下划线链接

 

注意：python中的标识符是区分大小写的

 

3.驼峰命名法：

     每一个单词的首字母都采用大写字母

      Eg:FirstName

 

 

要素三：组合数据类型

 

1.数据结构：通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合

 

2.python常用的组合数据类型：

  

A .序列类型：

   

列表：使用【】创建，是数字不加引号，字符串加引号，中间以逗号进行分割 如【‘call’‘me’,‘Ishmeal’,‘.’】

eg： >>> ll =["he","is","a","pig"]

     >>> ll[0]

      'he'

      >>> ll[0][0]

     'h'     

 

Eg:>>> print ll

['he', 'is', 'a', 'pig']

>>> ll[1]

'is'

>>> ll[3]

'pig'

>>> ll[3]='sheep'

>>> print ll

['he', 'is', 'a', 'sheep']   (列表是可变对象，而且在内存地址中的位置不发生改变id()查看)

 

Eg;

 

 

列表相加：

 Eg: [‘abc’,’def’] + [‘def’]

     [‘abc’,’def’,’def’]

Eg: [‘abc’,’def’] * 3

  [‘abc’’def’’abc’ ‘def’’abc’’def]

 

列表添加数字：

Eg: >>>a=[1,2]

>>>a.append(5)

>>>a

[1,2,5]

 

列表插入数字：

Eg:>>>a=[1,2,5]

>>>a.insert(1,2)

>>>a

[1,2,2,5]

 

列表修改：

 

>>>a[1]=0

>>>a

[1,0,2,5]

 

数字出现的次数：

 

List_a.count(5)

表示显示5出现的次数

 

移除数字：

 List_a.remove(5)

 

 

 

 

 

 

出栈：

 

 

4  表示弹出最后一个，让他出栈

 

Eg: >>>a

[1,0,3,2,5]

>>>a.pop(1) 让角标为1的出栈

0

从左向右数角标为0开始

 

 

B.  元组：使用（）创建，如（‘one’，‘two’） （不可变对象，除此之外跟列   表没有什么不同）

  eg：>>> t1=("this","is")

  >>> t1[0]

  'this'

   >>> t1[0][0]

  't'

 

 

 

 

 C.  字符串也属于序列类型 （可做切片使用）

 eg：>>> name='jerry'

     >>> name[0] （表示第0个）

     'j'

    >>> name[0:1] （表示第0个到第1个，但是第一个默认不显示）

    'j'

    >>> name[0:2]   （表示0个到一个）

    'je'

    >>> name[:2]    （表示第二个之前）

    'je'

    >>> name[2:]    （表示2到最后一个）

    'rry'

    >>> name[0:4]

    'jerr'

    >>> name[0:4:2]

    'jr'

 

切片问题：(切片本身会创造新的内存对象，切片自身不可变)

name是一个字符串，name[：]切片功能不涉及越界问题，[ m:n :k ] m是起始位置，n是终止位置，k是步长，当步长取-1时，可以实现整个字符串的倒置，而且取不到n，python下标从0开始，只能取到n-1位

 

Python中符合序列的有序序列都支持切片（slice），例如列表，字符串，元组。

     格式：【start:end:step】

     start:起始索引，从0开始，-1表示结束

     end：结束索引

     step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值

    注意切片的结果不包包含最后的一位含结束索引，即不，-1代表列表的最后一个位置索引

1 2 3

a=[1,2,3,4,5,6] b1=a[:] #省略全部，代表截取全部内容，可以用来将一个列表拷给另一个列表 print(b1)

结果：[1, 2, 3, 4, 5, 6]

1 2	b=a[0:-1:1] #从位置0开始到结束，每次增加1，截取。不包含结束索引位置 print(b)

结果：[1, 2, 3, 4, 5]

 

c1=a[:3] #省略起始位置的索引，以及步长。默认起始位置从头开始，默认步长为1，结束位置索引为3

print(c1)

结果：[1, 2, 3]

1

2

c=a[0:5:3] #从第一个位置到第留给位置，每3个取一个值

print(c)

结果：[1, 4]

 

1 2	d=a[5:0:-1] #反向取值 print(d)

结果：[6, 5, 4, 3, 2]

 

1 2	d1=a[::-1] print(d1)

结果：[6, 5, 4, 3, 2, 1]

 

Eg:

如果从开头截取到某个特定的位置可以用 [ : a]来表示

1. >>> Hebe = "xiaoxingyun"  

2. >>> Hebe[:3]  

3. 'xia'  

 

Eg:

 

 

 

 

这里有一点要说明， 在 pyhton中的字符串的索引序号可以是正数也可以是负数，从-1开始算

1. >>> Hebe = "xiaoxingyun"  

2. >>> Hebe[-1]  

3. 'n'  

4. >>> Hebe[-2]  

5. 'u'  

6. >>> Hebe[-3]  

7. 'y'  

8. >>> Hebe[-4]  

9. 'g'  

 

 

Eg;

 

这个时候我们可以还可以反向的取出一格字符串

[python] view plain copy

1. >>> Hebe="xiaoxingyun"  

2. >>> length=len(Hebe)  

3. >>> Hebe[::-1]  

4. 'nuygnixoaix'  

5. >>>   

 

  >>> hebe[::-2]

'nynxax'

 

 

D.集合类型：

 

   集合：

 

 

 

 

 

Eg;

 

>>> {1,2,3,4} - {3,4}

{1, 2}

>>> {1,2,3,4} & {3,4}

{3, 4}

 

>>> {1,2,34,5} | {5,7}

{1, 2, 34, 5, 7}

 

>>> s

{1, 2, 3}

>>> s.remove(3)

>>> s

{1, 2}

>>> s.remove(0)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 0

>>> s.remove(1)

>>> s

{2}

 

 

E. 映射类型

   字典

字典： 也是不可变对象，所以与元组可互相组合，不能与列表组合

字典删除del

 

 

 

 

>>> dicts = {"Mary":"mary@qq.com", "John": "John@mail.nwpu.edu","Miss Wu":None}

>>> dict = {"pason": 1}

>>> dict["pason"]

1

>>> if "Bob" not in dicts:

...     print("Hello!")   要缩进，并且按两次才能出现结果

...

 

 

                                          

F.列表是可变序列，元组是不可变序列

 

G.Python中，组合数据类型也是对象，因此其可以嵌套

   [“hello”“world”，[1,2,3] ]

 

H.实质上，列表和元组并不是真正存储数据，而是存放对象引用

 

I.python对象可以具有其可以被调用的特定“方法（函数）”

 

J.元组，列表以及字符串等数据类型是“有大小的”，也即，其长度可使用内置函数len()测量，（用len（）可以获取内部元素的个数）

 

Eg:     >>name="jerry"

        >>> len(name)

    5

 

   >>> ll=["this","is","a","jerry"]

   >>> len(ll)

 

    4  (表示的是4个元素)

 

 

 

 

==表示的是数值

Is 表示的身份是否相等，type和数值

 

元组和集合不一样，元组是有序列的所以不一样，集合是无序的所以是true,列表是也是可变序列

 

 

7.按位运算

 

 

要素4：逻辑操作符

 

1.逻辑运算是任何程序语言的基本功能

2.python提供了4组逻辑运算

  

A.身份操作符

Is:判定左端对象引用是否相同于右端对象引用：（就是看左右是否引用了同一个对象）也可以与None进行：

 

 Eg:

 >>> name="jerry"

 >>> test="jerry"

 >>> name is test  (is的意思就是name是否等于test,true表示他俩引用的是同一个对象)

 True

 

Eg:

>>> test="tom"

>>> name is test

False

 

Eg:

 >>> type(name)

 <type 'str'>

 >>> type(test)

 <type 'str'>

 >>> type(name) is type(test)

True

 

(所以说对象有可能不同，但是对象所属的类型可以相同)

 

 B.比较操作符

<,>，<=, >=, !=, ==

 通过比较获得布尔值

 

 

 

 C.成员操作符

in或not in :  测试成员关系

 

 D.逻辑运算符

And,or,not

 

 

 

 

要素5：控制流语句

 

控制流语句是过程式编程语言的基本控制机制

python的常见控制流语句：

 

If                                  if boolean_expression1:

                                     Suite1

While                               elif bootlean_exprssion2:

For...in                              suite2

Try                                  ....

                                     Else

                                     Else_suite

 

                                     While boolean_exression:

                                       Suite

                                      

                                     for  variable in iterable:

                                        Suite

If后边跟着的语句必须要有4个空格，无花括号

 

要素6：算数操作符

 

1.python提供了完整的算数操作符

2.很多的python数据类型也可以使用增强的赋值操作符，如+=，-=等

3.同样的功能，使用增强型赋值操作符的性能较好

4.python的int类型是不可变得，因此，增强型赋值的实际过程是创建了一个新的对象来存储结果后将变量名执行了重新绑定（m=m+1等于m+=1）

 

A.% 取余 5%2 =1

B.** 指数 2**2 =4

C.

D.+，-，*，/。//

E.+=，-=， *=，/=，//=

F.*= /=,//=

整数和浮点数进行运算时，自动转换为浮点数

 

要素7： 输入/输出：

 

现实中，具有实际功能的程序必须能够读取输入（如从键盘或文件中），以及产生输出，并写到终端或文件中；

 

1.python的输入/输出

  输出

Python3:print()函数

Python2:print语句

 

 

  输入(交互式输入)

   Input()

   Raw_input()   最好使用Raw_input()

   

Eg:

   >>> raw_input("plz input a num:")

   plz input a num:2

  '2'

  >>> a=raw_input("plz input a num:")

  plz input a num:a

  >>> print a

  a

 

2.python 解释器提供了3种标准文件对象。分别为标准输入，标准输出和标准     错误，他们在sys模块中分别以sys.stdin,sys.stdout和sys.stderr形式提供

 

 3. python的print 语句实现打印--一个对程序员友好的标准输出流接口

  

 4. 从技术角度来讲，print是吧一个或者多个对象转换为其文本表达形式，然后发送给标准输出或另一个类似文件的流

       在python 中，打印与文件和流的概念联系紧密

       文件写入方法是吧字符串写入到任意文件

       Print 默认吧对象打印到stdout流，并添加了一些自动的格式

5.实质上，print 语句只是python的人性化特性的具体实现，它提供了sys.stdout.write()的简单接口，再加一上些默认的格式设置

 

6.Print 接受一个逗号分隔的对象列表，并为行尾自动添加一个换行符，如果不需要，则在最后个元素后添加逗号

  Eg:>>> a=2

     >>> b=4

     >>> print a,b

     2 4

 

 

 

 

 

 

 

 

 

 

关于冒泡算法问题总结：

冒泡排序的时间复杂度是O(N^2)

冒泡排序的思想: 每次比较两个相邻的元素, 如果他们的顺序错误就把他们交换位置

比如有五个数: 12, 35, 99, 18, 76, 从大到小排序, 对相邻的两位进行比较

· 第一趟:

· 第一次比较: 35, 12, 99, 18, 76

· 第二次比较: 35, 99, 12, 18, 76

· 第三次比较: 35, 99, 18, 12, 76

· 第四次比较: 35, 99, 18, 76, 12

经过第一趟比较后, 五个数中最小的数已经在最后面了, 接下来只比较前四个数, 依次类推

· 第二趟
99, 35, 76, 18, 12

· 第三趟
99, 76, 35, 18, 12

· 第四趟
99, 76, 35, 18, 12
比较完成

冒泡排序原理: 每一趟只能将一个数归位, 如果有n个数进行排序,只需将n-1个数归位, 也就是说要进行n-1趟操作(已经归位的数不用再比较)

#!/usr/bin/env python# coding:utf-8

def bubbleSort(nums):

    for i in range(len(nums)-1):    # 这个循环负责设置冒泡排序进行的次数

        for j in range(len(nums)-i-1):  # ｊ为列表下标

            if nums[j] > nums[j+1]:

                nums[j], nums[j+1] = nums[j+1], nums[j]

    return nums

 

nums = [5,2,45,6,8,2,1]

print bubbleSort(nums)

 

 

 

 

Python中的合法标识符

 

 

1.不能以数字开头

>>> 2bin=2

  File "<stdin>", line 1

    2bin=2

       ^

SyntaxError: invalid syntax

2.不能包含非法字符

>>> ssd@f=1

  File "<stdin>", line 1

    ssd@f=1

       ^

SyntaxError: invalid syntax

3.数字不能作为标识符

>>> 123='wdsa'

SyntaxError: can't assign to literal

4.不能包含空格

>>> fds fds=1

  File "<stdin>", line 1

    fds fds=1

          ^

SyntaxError: invalid syntax

5.不能包含运算符

>>> sdf+sdf=1

SyntaxError: can't assign to operator

6.python保留关键字不能作为标识符

 

 

 

 

python第二天：

 

 

 

 

 

 

 

 

 

 

 

 

 

导入关键字 ，模块名加上包名再导入

 

 

 

 

 

例1：在new1这个包下同时定义两个模块

在demo1中 定义 p=1

在demo2中 导入输出

Import demo1

Print(demo1.p)即可

例2：

创建文件夹为old1,不是同级关系，所以导入的时候加上包名

 

例：import old1.old_damo1
print(old1.old_damo1.p)

例3：

demo1中

a=1
b=2
c=3

 

 

Demo2中导入变量

from demo1 import a,b,c  或者 *
       模块            变量
print(a,b,c)

 

或者不希望*直接导入完可以用，在非_init_.py中

 

 

 

 

                   

 

但是他单独导入还是可以的就是*的时候除外

???????在_init_中使用_all_

 

 

 

 

 

 

_init_.py的作用：

在子包下建立_init_.py中定义

在不同级的一个模块中调用，调用的时候随便import 子包下的一个文件他都能执行_init_.py

 

例4：在new1下重新建立一个子包old1 下有old_damo1.py和_init_.py ,在_init_.py 下在_init_.py中写入

   print("hello,world")

   在new1下建立一个模块叫做demo2 ,在demo2 中写入

import old1.old_damo1 as p

 

他会自动的触发_init_.py的执行，as为重命名

 

批量导入：

 

 

 

 

在Old1 下的_init_.py中写入

 

 

 

 

import new1.old1 as p
 print(p.sys)

 

 

 

 

 

 

 

 

 

 

第三天：

 

 

例题

import sys
sys.setrecursionlimit(1000)

def taijie(x):
    if x==1 or x==2:
        return n

#当n>2的时候

    return func(n-1) + func(n-2)
print(func(10))

 

 

 

 

 

例题：

 

 

 

 

 

 

 

     

 

 

 

 

 

 

 

 

 

例： 局部变量和全局变量

age = 20

def func():
    age =10
    print("In func()" + str(age))
    age = 30
func()
print(age)

 

In func()10

20

 

例题2

age = 20
#def func():
 #   global age
  #  print("In func()" + str(age))
   # age = 30

 #func()
# print(age)

 

In func()20

30

 

在变量之前加上global表示代表全局变量

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

没有赋值的放在一块赋值的放在一块，