python基本概念和语法

随着人工智能的发展，python语言也越来越受到青睐。逐渐成为了人工智能领域的首选编程语言，实际上python不仅在人工智能领域应用广泛，同样可以用于服务端开发（虽然服务端是Java的主场）。目前Python是排名前3的最受欢迎和增长最快的编程语言之一，在一些语言排行榜上Python已经跃居首位，在TIOBE语言排行榜上，Python也仅次于Java和C，来发展前景非常广阔。它是一种多用途，高级别，面向对象，交互式，解释型和对用户非常友好的编程语言。由于工作原因利用零碎的时间学习使用python，本文是对Python基本使用的总结，一些入门级知识和概念的记录

Python可以做什么

学习一门语言首先要明白它能做什么，Python 的主流的领域，当下全栈工程师的概念很火，而Python是一种全栈的开发语言，所以你如果能学好Python，那么前端，后端，测试，大数据分析，爬虫等这些工作你都能胜任。python的主要应用领域有以下几个方面

1. 网络爬虫：说起爬虫很多第一想到的就python吧 ， 网络爬虫又称网络蜘蛛，是指按照某种规则在网络上爬取所需内容的脚本程序。相比与其他静态编程语言，如java，c#，c++，python抓取网页文档的接口更简洁；相比其他动态脚本语言，如perl，shell，python的urllib2包提供了较为完整的访问网页文档的API。
2. 科学计算：说起科学计算，首先会被提到的可能是MATLAB。然而除了MATLAB的一些专业性很强的工具箱还无法替代之外，MATLAB的大部分常用功能都可以在Python世界中找到相应的扩展库。
3. 游戏编程：Python在很早的时候就是一种游戏编程的辅助工具。在《星球大战》中扮演了重要的角色。目前，通过Python完全可以编写出非常棒的游戏程序。
4. 多媒体：利用PIL、Piddle、ReportLab 等模块,你可以处理图象、声音、视频、动画等，从而为你的程序添加亮丽的光彩。动态图表的生成、统计分析图表都可以通过Python来完成。
5. 网站开发：web开发现在用 Python 的也不少了，开发起来简单又高效，因为 Python 也有网站开发相关的框架，比如 Flask、Django、Bottle。有了它们，不管你是开发个人网站也好，企业网站也罢， Python 都能胜任。
6. 自动化运维：随着技术的进步、业务需求的快速增长，一个运维人员通常要管理上百、上千台服务器，运维工作也变的重复、繁杂。把运维工作自动化，能够把运维人员从服务器的管理中解放出来，让运维工作变得简单、快速、准确。用Python 来写是很爽的，那些频繁的、重复的、无脑的操作，你都可以自己写一个 Python 脚本让电脑帮你操作，可以节省你大量的时间。
7. 自动化测试：编写为简单的实现脚本，运用在Selenium/lr中，实现自动化。

Python的特点

1. 简单易学：Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样。它使你能够专注于解决问题而不是去搞明白语言本身。Python极其容易上手，因为Python有极其简单的说明文档。
2. 高层语言：用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。垃圾回收机制似乎是高级语言的标配了
3. 可移植性：于 Python 是开源的，它已经被移植到许多平台上。如果能够避免使用依赖系统的特性，那就意味着，所有 Python 程序都无需修改就可以在好多平台上运行，包括 Linux、Windows、FreeBSD、Solaris 等等，甚至还有 PocketPC、Symbian 以及 Google 基于 Linux 开发的 Android平台。
4. 解释型语言：一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行 程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。这使得使用Python更加简单。也使得Python程序更加易于移植。
5. 面向对象：Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。
6. 可扩展性：Python 的可扩展性体现为它的模块，Python 具有脚本语言中最丰富和强大的类库，这些类库覆盖了文件 I/O、GUI、网络编程、数据库访问、文本操作等绝大部分应用场景。Python 可扩展性一个最好的体现是，当我们需要一段关键代码运行的更快时，可以将其用 C 或 C++ 语言编写，然后在 Python 程序中使用它们即可。
7. 丰富的库：Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的 “功能齐全” 理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。

Python的基本数据类型

python3的基本数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）、其中Number又可细分为整数型，浮点型，复数型，布尔型（布尔型为什么会被划分在Number类型下面呢？在Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。）。python是弱类型语言，会在运行时根据上下文自动识别变量类型

布尔类型

在Python中，None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了nonzero()或len()方法且方法返回0或False，则其实例也被当作False，其他对象均为True 。布尔值还可以用and、or和not运算。

整型(Int)

在Python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，通常都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制 。Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

浮点型(Float)

Python的浮点数就是数学中的小数，类似C语言中的double。 在运算中，整数与浮点数运算的结果是浮点数 。浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。 整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

字符串(String)

Python字符串即可以用单引号也可以用双引号括起来，甚至还可以用三引号括起来 字符串是以”或”“括起来的任意文本，比如’abc’，”xyz”等等。请注意，”或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用”“括起来，比如”I’m OK”包含的字符是I，’，m，空格，O，K这6个字符。
如果字符串内部既包含’又包含”怎么办？可以用转义字符\来标识

def dataType():
    # 整数类型
    a=12
    print(type(a))
    print(isinstance(a, int))
    # 浮点类型
    b=3.14
    print(type(b))
    print(isinstance(b, float))
    # 布尔类型
    c=True
    print(type(c))
    print(isinstance(c, bool))
    # 复数类型
    d=4+3j
    print(type(d))
    print(isinstance(d, complex))
    # 字符类型
    e='python'
    print(type(e))
    print(isinstance(e, str))

if __name__=='__main__':
    dataType()

输出结果如下

<class 'int'>
True
<class 'float'>
True
<class 'bool'>
True
<class 'complex'>
True
<class 'str'>
True

列表(List)

用符号[]表示列表，中间的元素可以是任何类型，用逗号分隔。list类似C语言中的数组，用于顺序存储结构 。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

list = ['abcd',213,2.98,'okokkok',70.2,['aaa',12]]
tinylist = [123,'kokoko']

print(list)   #输出完整列表
print(list[0])  #输出列表第一个元素
print(list[1:3]) #输出列表的第2个元素至第4个元素
print(list[3:])  #输出列表第4个元素以及之后的元素
print(tinylist * 2)  #输出列表两次
print(list + tinylist)  #连接列表
print(list[-1]) #输出嵌套列表
print(list[-1][1]) #输出嵌套列表中的第2个元素

输出结果

# 运行结果如下 #
['abcd', 213, 2.98, 'okokkok', 70.2, ['aaa', 12]]
abcd
[213, 2.98]
['okokkok', 70.2, ['aaa', 12]]
[123, 'kokoko', 123, 'kokoko']
['abcd', 213, 2.98, 'okokkok', 70.2, ['aaa', 12], 123, 'kokoko']
['aaa', 12]
12

Tuple(元组)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：

tuple = ('abd', 123, 12.22,'ios',(123,'342'))
tinytuple = (3242,'dsf')

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

# 运行结果如下
('abd', 123, 12.22, 'ios', (123, '342'))
abd
(123, 12.22)
(12.22, 'ios', (123, '342'))
(3242, 'dsf', 3242, 'dsf')
('abd', 123, 12.22, 'ios', (123, '342'), 3242, 'dsf')

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。其实，可以把字符串看作一种特殊的元组。

Set(集合)

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。创建格式：

parame = {value01,value02,…}
#或者
set(value)

举个例子：

student = {'Tom','Jim','Marry','Tom','Jack','Rose'}

print(student)  #输出集合，重复的元素会被自动去掉，且每次输出顺序不同

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

#set可以进行集合运算
a = set('abcdefg')
b = set('alaceio')
print(a)
print(a-b) #a和b的差集
print(a|b) #a和b的并集
print(a&b) #a和b的交集
print(a^b) #a和b中不同时存在的元素

# 运行结果如下
{'Rose', 'Jack', 'Marry', 'Jim', 'Tom'}
Rose在集合中
{'f', 'b', 'e', 'c', 'g', 'd', 'a'}
{'b', 'g', 'd', 'f'}
{'f', 'i', 'l', 'e', 'b', 'c', 'o', 'g', 'd', 'a'}
{'a', 'e', 'c'}
{'o', 'd', 'f', 'i', 'l', 'b', 'g'}

字典(Dictionary)

列表是有序的集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用{}标识，他是一个无序的　键(key):值(value)的集合。键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

dict = {}
dict['one'] = '1-Python'
dict[2] = '2-Python'

tinydict = {'name':'okokokok', 'age':1, 'site':'fasklh'}

print(dict['one'])
print(dict[2])
print(tinydict)
print(tinydict.keys())
print(tinydict.values())


# 运行结果如下
1-Python
2-Python
{'name': 'okokokok', 'age': 1, 'site': 'fasklh'}
dict_keys(['name', 'code', 'site'])
dict_values(['okokokok', 1, 'fasklh'])

构造函数dict()可以从键值对序列中构建字典如下

>>> dict([('heu',1),('dianzi',2),('no',3)])
{'heu': 1, 'dianzi': 2, 'no': 3}
>>> dict(heu=1,dianzi=2,no=3)
{'heu': 1, 'dianzi': 2, 'no': 3}
>>> {x:x**2 for x in (3,6,9)}
{3: 9, 6: 36, 9: 81}
>>> dict(heu=1,'dianzi'=2,no=3) #key类型不同创建失败
  File "<stdin>", line 1
SyntaxError: keyword can't be an expression

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

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

Python的变量作用域

就作用域而言，Python与C有着很大的区别，在Python中并不是所有的语句块中都会产生作用域。只有当变量在Module(模块)、Class(类)、def(函数)中定义的时候，才会有作用域的概念。作用范围从小到大为，小作用域的可以调用大作用域的内容。1.局部 Local；2.闭包 Enclosing；3.全局 Global；4.内建 Build-in。

L(local)局部作用域

局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。

def example():
    v=1  #局部变量
print(v)

# 运行结果如下
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    print(v)
NameError: name 'v' is not defined

由于局部变量作用域只在函数内部有效，因此程序会报错

E(enclosing)闭包作用域

在python中“一切皆对象”，因此函数也被看作对象，因此产生了一种特殊的形式函数嵌套。E也包含在def关键字中，E和L是相对的，E相对于更上层的函数而言也是L。与L的区别在于，对一个函数而言，L是定义在此函数内部的局部作用域，而E是定义在此函数的上一层父级函数的局部作用域。主要是为了实现Python的闭包，而增加的实现。闭包是在内嵌函数生成的时候将其用到的环境以及自己本身都封装在了一起。为了直观理解闭包，我们介绍一下code对象，code对象是指代码对象，表示编译成字节的的可执行Python代码，或者字节码。它有几个比较重要的属性：

• co_name: 函数的名称

• co_nlocals: 函数使用的局部变量的个数

• co_varnames: 一个包含局部变量名字的元组

• co_cellvars: 是一个元组，包含嵌套的函数所引用的局部变量的名字

• co_freevars: 是一个元组，保存使用了的外层作用域中的变量名

• co_consts: 是一个包含字节码使用的字面量的元组

有如下程序

def out_func():
    a = 1
    b = 2
    c = 3
    def iner_func1():
        return a + 1

    def iner_func2():
        return b + 1

    return iner_func1

func=out_func()
print(out_func.__code__.co_varnames)
print(out_func.__code__.co_cellvars)
print(out_func.__code__.co_freevars)

print(func.__code__.co_varnames)
print(func.__code__.co_cellvars)
print(func.__code__.co_freevars)


# 运行结果如下
('c', 'iner_func1', 'iner_func2')
('a', 'b')
()
()
()
('a',)

1. 前三个输出是关于外部函数的一些属性，由于out_func函数中声明了几个局部变量，因此包含三个变量。第二个输出是内部的函数用到的变量，而iner_func1与iner_func2用到了变量a与b。第三个输出是使用了的外部作用域的变量，因此是空。
2. 后三个输出是关于内部函数的一些属性，前两个输出由于iner_func1没有使用到因此为空，由于iner_func1用到了外部变量a，因此只有变量a。

G(global)全局作用域

即在模块层次中定义的变量，每一个模块都是一个全局作用域。也就是说，在模块文件顶层声明的变量具有全局作用域，从外部开来，模块的全局变量就是一个模块对象的属性。注意：全局作用域的作用范围仅限于单个模块文件内，此外python与C，Java有许多不同的地方，例子如下

v=1
def example():
    v=2
    print(v)
example()
print(v)


# 运行结果如下
2
1

当想要在函数中对全局变量进行赋值时，如上操作，python会生成新的局部变量，而不是修改全局变量的值，可以通过global标记在局部作用域中声明全局变量。正确使用如下

v=1
def example():
    global v
    v=2
    print(v)
example()
print(v)


# 运行结果如下
2
2

B(built-in)内置作用域

系统内固定模块里定义的变量，如预定义在builtin 模块内的变量。

变量名解析LEGB法则

搜索变量名的优先级：局部作用域 > 嵌套作用域 > 全局作用域 > 内置作用域
LEGB法则： 当在函数中使用未确定的变量名时，Python会按照优先级依次搜索4个作用域，以此来确定该变量名的意义。首先搜索局部作用域(L)，之后是上一层嵌套结构中def或lambda函数的嵌套作用域(E)，之后是全局作用域(G)，最后是内置作用域(B)。按这个查找原则，在第一处找到的地方停止。如果没有找到，则会出发NameError错误。下面代码标识了各类型变量的声明定义

globalVar = 100           #G

def test_scope():
    enclosingVar = 200    #E
    def func():
        localVar = 300    #L
print __name__            #B

为了更好理解，下面举个例子

def test_scopt():
    variable = 200
    print(variable)
    def func():
        print(variable)   #这里的变量variable在E中绑定了内存对象200，为函数func()引入了一个新的变量
    func()
variable = 100
test_scopt()
print(variable)

# 输出结果如下
200
200
100

注意

1. python能够产生作用域的代码段是 def、class、lambda.
2. python能够不能产生作用域的代码段是 if-elif-else、for/while、try/except/finally

例子1：

if True:
    variable = 100
    print (variable)
print ("******")
print (variable)

# 输出结果如下
100
******
100

例子2

while True:
    newvar=8
    print(newvar)
    break;

print(newvar)

try:
    newlocal=7
    raise Exception
except:
    print(newlocal)#可以直接使用哦

# 输出结果如下
8
8
7

Python在变量作用域上与C和Java有比较大的区别，在使用时一定要区分好，牢记LEGB法则法则