python基础整理1

 

基础知识

 名字与对象，类与类型

变量：在Python中，存储一个数据，须要一个叫作变量的东西   num2 = 87 #num2是一个变量

变量的类型：

程序中为了更充分的利用内存空间以及更有效率的管理内存，变量是有不一样的类型的，以下所示:

 

 

输入：python3版本中  input    python2中raw_input()

输出：print

 

 

内置对象，自定义对象，实列化

 

 

 

 

 关键字：python一些具备特殊功能的标示符，这就是所谓的关键字

关键字，是python已经使用的了，因此不容许开发者本身定义和关键字相同的名字的标示符

 

 

 

 

数据类型

一、      数字：用于存储数值。包括整型(Int)，长整型(long integers) ，浮点型(floating point real values)，复数(complex numbers)

二、      布尔值     真或假  1 或 0

三、      字符串  :双引号或者单引号中的数据，就是字符串

 

字符串经常使用功能：

• 移除空白
• 分割
• 长度
• 索引
• 切片

四、      列表:列表使用方括号——[]

基本操做：

• 索引
• 切片
• 追加
• 删除
• 长度
• 循环
• 包含

五、元祖  :元组的元素不能修改。元组使用小括号——（）组建立很简单，只须要在括号中添加元素，并使用逗号隔开便可

基本操做：

• 索引
• 切片
• 循环
• 长度
• 包含

六、字典（无序）：字典的每一个键值 key=>value 对用冒号 : 分割，每一个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

 

 经常使用操做：

• 索引
• 新增
• 删除
• 键、值、键值对
• 循环
• 长度

 

遍历

 

经过for ... in ...:的语法结构，咱们能够遍历字符串、列表、元组、字典等数据结构。

 

注意python语法的缩进

 

字符串遍历

 

>>> a_str = "hello itcast" >>> for char in a_str: ... print(char,end=' ') ... h e l l o i t c a s t 

 

列表遍历

 

>>> a_list = [1, 2, 3, 4, 5] >>> for num in a_list: ... print(num,end=' ') ... 1 2 3 4 5 

 

元组遍历

 

>>> a_turple = (1, 2, 3, 4, 5) >>> for num in a_turple: ... print(num,end=" ") 1 2 3 4 5 

 

字典遍历

 

<1> 遍历字典的key（键）

 

<2> 遍历字典的value（值）

 

 

<3> 遍历字典的项（元素）

 

 

<4> 遍历字典的key-value（键值对）

 

 

可变类型与不可变类型

可变类型，值能够改变：

• 列表 list
• 字典 dict

不可变类型，值不能够改变：

• 数值类型 int, long, bool, float
• 字符串 str
• 元组 tuple

 

流程控制

分支结构

需求1、用户登录验证

# 提示输入用户名和密码

  

# 验证用户名和密码

#     若是错误，则输出用户名或密码错误

#     若是成功，则输出 欢迎，XXX!

 

需求2、根据用户输入内容输出其权限

# 根据用户输入内容打印其权限

  

# alex --> 超级管理员

# eric --> 普通管理员

# tony,rain --> 业务主管

# 其余 --> 普通用户

 

循环结构

1：while循环

while 条件:

# 循环体

 # 若是条件为真，那么循环体则执行

# 若是条件为假，那么循环体不执行

 

二、break

break用于退出全部循环

三、continue

continue用于退出当前循环，继续下一次循环

 

函数——为了提升编写的效率以及代码的重用，因此把具备独立功能的代码块组织为一个小模块，这就是函数，函数式编程最重要的是加强代码的重用性和可读自性

python内置函数

 

 

 

Python包含了如下内置函数

 

 

 

序号	方法	描述
1	cmp(item1, item2)	比较两个值
2	len(item)	计算容器中元素个数
3	max(item)	返回容器中元素最大值
4	min(item)	返回容器中元素最小值
5	del(item)	删除变量

 

注意：cmp在比较字典数据时，先比较键，再比较值。

 

注意：len在操做字典数据时，返回的是键值对个数。

 

del有两种用法，一种是del加空格，另外一种是del()

 

 

Python 内置函数

		内置函数
abs()	divmod()	input()	open()	staticmethod()
all()	enumerate()	int()	ord()	str()
any()	eval()	isinstance()	pow()	sum()
basestring()	execfile()	issubclass()	print()	super()
bin()	file()	iter()	property()	tuple()
bool()	filter()	len()	range()	type()
bytearray()	float()	list()	raw_input()	unichr()
callable()	format()	locals()	reduce()	unicode()
chr()	frozenset()	long()	reload()	vars()
classmethod()	getattr()	map()	repr()	xrange()
cmp()	globals()	max()	reverse()	zip()
compile()	hasattr()	memoryview()	round()	__import__()
complex()	hash()	min()	set()
delattr()	help()	next()	setattr()
dict()	hex()	object()	slice()
dir()	id()	oct()	sorted()	exec 内置表达式

自定义函数

def 函数名(参数):             ...     函数体     ...     返回值

 

函数的定义主要有以下要点：

• def：表示函数的关键字
• 函数名：函数的名称，往后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，能够给调用者返回数据。（函数是一个功能块，该功能到底执行成功与否，须要经过返回值来告知调用者。）

 

调用函数

定义了函数以后，就至关于有了一个具备某些功能的代码，想要让这些代码可以执行，须要调用它

调用函数很简单的，经过 函数名() 便可完成调用

 

函数参数(一)

<1> 定义带有参数的函数

示例以下：

def add2num(a, b): c = a+b print c 

<2> 调用带有参数的函数

以调用上面的add2num(a, b)函数为例:

def add2num(a, b): c = a+b print c add2num(11, 22) #调用带有参数的函数时，须要在小括号中，传递数据

• 定义时小括号中的参数，用来接收参数用的，称为 “形参”
• 调用时小括号中的参数，用来传递给函数用的，称为 “实参”

函数返回值(一)

<1>“返回值”介绍

• 所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

• <2>带有返回值的函数

• 想要在函数中把结果返回给调用者，须要在函数中使用return

 

<3>保存函数的返回值

若是一个函数返回了一个数据，那么想要用这个数据，那么就须要保存

4种函数的类型

函数根据有没有参数，有没有返回值，能够相互组合，一共有4种

• 无参数，无返回值
• 无参数，有返回值
• 有参数，无返回值
• 有参数，有返回值

• <1>无参数，无返回值的函数

  此类函数，不能接收参数，也没有返回值，通常状况下，打印提示灯相似的功能，使用这类的函数

• <2>无参数，有返回值的函数

  此类函数，不能接收参数，可是能够返回某个数据，通常状况下，像采集数据，用此类函数

• <3>有参数，无返回值的函数

  此类函数，能接收参数，但不能够返回数据，通常状况下，对某些变量设置数据而不需结果时，用此类函数

• <4>有参数，有返回值的函数

  此类函数，不只能接收参数，还能够返回某个数据，通常状况下，像数据处理并须要结果的应用，用此类函数

• 小总结

  • 函数根据有没有参数，有没有返回值能够相互组合
  • 定义函数时，是根据实际的功能需求来设计的，因此不一样开发人员编写的函数类型各不相同

 

函数的嵌套调用

一个函数里面又调用了另一个函数，这就是所谓的函数嵌套调用 

• 若是函数A中，调用了另一个函数B，那么先把函数B中的任务都执行完毕以后才会回到上次 函数A执行的位置

 

 

局部变量

<1>什么是局部变量

以下图所示:

 

 

 

<2>小总结

• 局部变量，就是在函数内部定义的变量
• 不一样的函数，能够定义相同的名字的局部变量，可是各用个的不会产生影响
• 局部变量的做用，为了临时保存数据须要在函数中定义变量来进行存储，这就是它的做用

 

 

全局变量

<1>什么是全局变量

若是一个变量，既能在一个函数中使用，也能在其余的函数中使用，这样的变量就是全局变量

 

 

<4>总结1:

• 在函数外边定义的变量叫作全局变量
• 全局变量可以在全部的函数中进行访问
• 若是在函数中修改全局变量，那么就须要使用global进行声明，不然出错
• 若是全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧强龙不压地头蛇

 

<5>可变类型的全局变量

• 函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
• 对于不可变类型的全局变量来讲，因其指向的数据不能修改，因此不使用global时没法修改全局变量。
• 对于可变类型的全局变量来讲，因其指向的数据能够修改，因此不使用global时也可修改全局变量。

 

函数参数(二)

1. 缺省参数

调用函数时，缺省参数的值若是没有传入，则被认为是默认值

注意：带有默认值的参数必定要位于参数列表的最后面。

2.不定长参数

有时可能须要一个函数能处理比当初声明时更多的参数。这些参数叫作不定长参数，声明时不会命名。

基本语法以下：

def functionname([formal_args,] *args, **kwargs): "函数_文档字符串" function_suite return [expression] 

加了星号（*）的变量args会存放全部未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

 

3. 引用传参

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，因此运算不会影响到变量自身；而对于可变类型来讲，函数体中的运算有可能会更改传入的参数变量。

函数使用注意事项

1. 自定义函数

<1>无参数、无返回值

def 函数名(): 语句

<2>无参数、有返回值

def 函数名(): 语句 return 须要返回的数值

注意:

• 一个函数到底有没有返回值，就看有没有return，由于只有return才能够返回数据
• 在开发中每每根据需求来设计函数需不须要返回值
• 函数中，能够有多个return语句，可是只要执行到一个return语句，那么就意味着这个函数的调用完成

<3>有参数、无返回值

def 函数名(形参列表): 语句

注意：

• 在调用函数时，若是须要把一些数据一块儿传递过去，被调用函数就须要用参数来接收
• 参数列表中变量的个数根据实际传递的数据的多少来肯定

<4>有参数、有返回值

def 函数名(形参列表): 语句 return 须要返回的数值

<5>函数名不能重复

2. 调用函数

<1>调用的方式为：

函数名([实参列表])

<2>调用时，到底写不写 实参

• 若是调用的函数 在定义时有形参，那么在调用的时候就应该传递参数

<3>调用时，实参的个数和前后顺序应该和定义函数中要求的一致

<4>若是调用的函数有返回值，那么就能够用一个变量来进行保存这个值

3. 做用域

<1>在一个函数中定义的变量，只能在本函数中用(局部变量)

<2>在函数外定义的变量，能够在全部的函数中使用(全局变量)

 

 

 

递归函数

 

<1>什么是递归函数

 

经过前面的学习知道一个函数能够调用其余函数。

 

若是一个函数在内部不调用其它的函数，而是本身自己的话，这个函数就是递归函数。

 

 闭包

什么是闭包：内部函数对外部函数做⽤域⾥变量的引⽤（⾮全局变量），则称内部函数为 闭包。

 

 

闭包思考：
1.闭包似优化了变量，原来须要类对象完成的⼯做，闭包也能够完成 2.因为闭包引⽤了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存

匿名函数

 

用lambda关键词能建立小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

 

lambda函数的语法只包含一个语句，以下：

 

lambda [arg1 [,arg2,.....argn]]:expression

以下实例：

sum = lambda arg1, arg2: arg1 + arg2 #调用sum函数 print "Value of total : ", sum( 10, 20 ) print "Value of total : ", sum( 20, 20 ) 

以上实例输出结果：

Value of total : 30 Value of total : 40 

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

匿名函数不能直接调用print，由于lambda须要一个表达式

 

应用场合

 

 

 

 

 

 

 

经常使用模块

 说的通俗点：模块就比如是工具包，要想使用这个工具包中的工具(就比如函数)，就须要导入这个模块

 

<2>import

 

在Python中用关键字import来引入某个模块，好比要引用模块math，就能够在文件最开始的地方用import math来引入。

 

形如:

 

import module1,mudule2... 

 

当解释器遇到import语句，若是模块在当前的搜索路径就会被导入。

 

在调用math模块中的函数时，必须这样引用：

 

　　模块名.函数名

有时候咱们只须要用到模块中的某个函数，只须要引入该函数便可，此时能够用下面方法实现：

from 模块名 import 函数名1,函数名2....

不只能够引入函数，还能够引入一些全局变量、类等

• 注意:

  • 经过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，可是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( )，在模块B中也有函数function( )，若是引入A中的function在先、B中的function在后，那么当调用function函数的时候，是去执行模块B中的function函数。

  • 若是想一次性引入math中全部的东西，还能够经过from math import *来实现

<3>from…import

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中

语法以下：

from modname import name1[, name2[, ... nameN]] 

例如，要导入模块fib的fibonacci函数，使用以下语句：

from fib import fibonacci 

注意

• 不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入

<4>from … import *

把一个模块的全部内容全都导入到当前的命名空间也是可行的，只需使用以下声明：

from modname import * 

注意

• 这提供了一个简单的方法来导入一个模块中的全部项目。然而这种声明不应被过多地使用。

<5> as

In [1]: import time as tt

    In [2]: time.sleep(1)

<6>定位模块

当你导入一个模块，Python解析器对模块位置的搜索顺序是：

1. 当前目录
2. 若是不在当前目录，Python则搜索在shell变量PYTHONPATH下的每一个目录。
3. 若是都找不到，Python会察看默认路径。UNIX下，默认路径通常为/usr/local/lib/python/
4. 模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

模块制做

<1>定义本身的模块

在Python中，每一个Python文件均可以做为一个模块，模块的名字就是文件的名字。

好比有这样一个文件test.py，在test.py中定义了函数add

test.py

def add(a,b): return a+b 

<2>调用本身定义的模块

那么在其余文件中就能够先import test，而后经过test.add(a,b)来调用了，固然也能够经过from test import add来引入

main.py

import test result = test.add(11,22) print(result) 

<3>测试模块

在实际开中，当一个开发人员编写完一个模块后，为了让模块可以在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：

test.py

def add(a,b): return a+b # 用来进行测试 ret = add(12,22) print('int test.py file,,,,12+22=%d'%ret) 

若是此时，在其余py文件中引入了此文件的话，想一想看，测试的那段代码是否也会执行呢！

main.py

import test result = test.add(11,22) print(result)

总结：

• 能够根据__name__变量的结果可以判断出，是直接执行的python脚本仍是被引入执行的，从而可以有选择性的执行测试代码

模块中的__all__

1. 没有__all__

 

2. 模块中有__all__

 

 

 

总结

• 若是一个文件中有__all__变量，那么也就意味着这个变量中的元素，不会被from xxx import *时导入

 

python中的包

1. 引入包

1.1 有2个模块功能有些联系

 

 

 

1.2 因此将其放到同一个文件夹下

 

 

1.3 使用import 文件.模块 的方式导入

 

 

1.4 使用from 文件夹 import 模块 的方式导入

 

 

1.5 在msg文件夹下建立__init__.py文件

1.6 在__init__.py文件中写入

 

 

1.7 从新使用from 文件夹 import 模块 的方式导入

总结：

• 包将有联系的模块组织在一块儿，即放到同一个文件夹下，而且在这个文件夹建立一个名字为__init__.py 文件，那么这个文件夹就称之为包
• 有效避免模块名称冲突问题，让应用组织结构更加清晰

• 2. __init__.py文件有什么用

  __init__.py 控制着包的导入行为

  2.1 __init__.py为空

  仅仅是把这个包导入，不会导入包中的模块

  2.2 __all__

  在__init__.py文件中，定义一个__all__变量，它控制着 from 包名 import *时导入的模块

  2.3 (了解)能够在__init__.py文件中编写内容

  能够在这个文件中编写语句，当导入时，这些语句就会被执行

  __init__.py文件 

• 模块安装、使用

  1.安装的方式

  1. 找到模块的压缩包
  2. 解压
  3. 进入文件夹
  4. 执行命令python setup.py install

  注意：

  • 若是在install的时候，执行目录安装，可使用python setup.py install --prefix=安装路径

  2.模块的引入

  在程序中，使用from import 便可完成对安装的模块使用

  from 模块名 import 模块名或者*