我自己整理的一点python的学习笔记。后续继续更新

最新推荐文章于 2024-03-23 06:42:39 发布

joliny

最新推荐文章于 2024-03-23 06:42:39 发布

阅读量4.1k

点赞数

分类专栏： python 文章标签： python object import string function lambda

本文链接：https://blog.csdn.net/joliny/article/details/7346686

版权

python 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

1、可以采用反斜杠\明确添加一个后续行。

2、以：结束多行语句。

例如：if i=2：

pass；

3、注释方式

a、注释一行用# 例如：#i=2

4、python文本程序

Unix下的python脚本，需要在脚本首行设置一个“shebang",该行声明python解释器在系统中的位置。

例如：#!/usr/local/bin/python

今天，更流行的写法，而且与python安装位置无关：#!/usr/bin/env python

可以通过whereis python命令查找python在Unix系统中的所在位置。同时采用chmod +x scriptname.py 把脚本的许可部分设置为755，以便每个用户都可以执行它。

5、如果要在执行完一个程序后打开解释器，则在调用脚本时使用-i变元。否则脚本执行之后，将自动关闭解释器。

例如：python -i scriptname.py

6、主意：制表符在内部转换成空格（1个制表符=8个空格）空行是忽略的脚本when部分。

7、如果一行拥有多个语句，则需要使用分毫把它们隔开。

例如： print "When AH"; print "were young..."

需要分解成两行的行末尾设置反斜杠\:

例如 t="Nobody expects" + \

"the Spanish inquisition"

8、Python程序中无需声明变量类型。同一变量名称在不同场合可能拥有不同类型，因为每次给变量分配一个值时都要重新初始化它。

9、python中无需释放变量。因为python进行引用计数，当变量引用计数减至0时，则可以把它作为无用信息进行收集。Cpython中，引用计数一抵达0就释放对象。

10、python中的保留字

and assert break class continue def del elif else except exec finally for from global if import in is lambda not or pass print raise return while

11、python中的标识符

A~Z a~z 0~9以及_。但是，标识符不能以数字开头。

python标识符是大小写敏感的。

专用字符：$,%和@不能做标识符名称部分。此外，$和@只能用在程序中的引证字符串内。%字符可在程序中使用，因为它是mod运算符。

12、python中的内置数据类型

a、不可变数据类型：字符串，数值以及元组

b、可变数据类型：列表，字典

注意：

Python支持长整形，而且长度不受限制。为了让python把整数处理为长整形，则需要在数字末尾设置一个L。

python把字符串当做字符序列。

13、真假逻辑值

假由零，空结构或者值None表示。

真由不为零的结果值和非空结构表示。

14、python内置函数

载入python解释器时，总可以获得如下所列函数。因为它们是__builtin__模块的组成部分，该模块总随python的启动而导入。

apply()该函数执行一个给定函数，传递所提供的变元。

基本语法:apply(function,(tuple of positional arguments),[dictionary of keywords arguments])

>>> apply (raise_salary,(6000),{'emplyee':'john','id':13})

coerce()用于尝试把两个给定变元x和y转变成同一类型，并把它们作为元组返回。

基本语法：coerce(x,y)

>>> coerce(43,5.4) ====>(43.0,5.4)

filter()该函数通过制定function筛选原list的每个元素生成一个新的列表，筛选原则是函数评价为真

基本语法：filter(function,list)

>>> filter(lambda x : x<3,range(4)) ======>[0,1,2]

golobals()该函数返回全局名字空间字典

基本语法：golobals()

input() 该函数为用户提供一个输入接口。只接受数字。

基本语法：input([prompt])

>>> a= input("please, type a number greater than 5:")

locals()该函数返回一个局部名字空间字典。

基本语法：locals()

map()该函数把一个制定的function应用于list的每项元素，生成另一个列表。如果把指定函数设置成None并提供多个列表，则生成列表形式的元组矩阵。

>>> lst = map (None,[1,2,3,4],[1,2,3,4,5,6])

>>> lst ===> [(1,1),(2,2),(3,3),(4,4),(None,5),(None,6)]

open()该函数打开一个文件对象

基本语法：open(filename[,model[,bufsize]])

pow()该函数范围x**y或者（x**y)%z,具体取决于传递变元的个数

基本语法:pow(x,y[,z])

raw_input()该函数从标准输入（sys.stdin)读取，把所读取数据作为字符串返回。prompt是可在屏幕上显示的可选文字。

基本语法：raw_input([prompt])

reduce()该函数向sequence中的元素项累加应用一个function（隐式循环），返回单个值。initializer是可选开始值

基本语法：reduce(function,sequence[,initializer])

>>> import operator

>>> reduce(operator.add,[1,2,3]) =====> 6

__import__()导入语句调用的函数。为了导入一个模块，只需通告module name即可。

基本语法：__import__(module_name,[,globals()[,locals()[,from list]]))

>>> string = __import__("string")

reload()该函数重新加载一个已导入的模块，它在reload()内调用__import__()函数

序列函数

range()该函数根据所传输信息返回一个数值列表

基本语法：variable=range([initial_value,]final_value-1[,step])

>>> lst = range(1,5) ===> lst结果是[1,2,3,4]

xrange()类似于range(),但不想一个变量分配返回列表，因而前者使用的内存没有后者多。因此，即使键入xrange(2000000000000000)也不会引起内存不足。

基本语法：xrange([initial_value,]final_value-1[,step])

len()该函数返回字符串元素的长度

基本语法：len(variablename)

max()该函数返回sequence的最大（最长）元素

基本语法：max(sequence)

>>> max(1,2,3) ===> 3

>>> max("my brain hurts)===>"Y"

min()该函数返回sequence的最小元素

基本语法：min(sequence)

zip()是一个多元组组成的列表，其中每个元组包含来自每个给定序列的第i个元素。该函数生成一个结果列表，其长度正好与最短给定序列的长度相同。另外注意，序列长度不同时，函数map(None,sequence1,sequence2,...)用None填补结果列表。

基本语法：zip(sequence1,sequence2,sequence3,...)

对象操作

setattr()该函数为object.name设置新值。

基本语法：setattr(object,name,value)

getattr()该函数从object返回attractive。该函数等价于object.attribute

基本语法：getattr(object,attribute)

hasattr()如果object拥有attribute，该函数返回1；否则返回0

基本语法: hasattr(object,attribute)

delattr()该函数从object删除attribute。该函数等价于 del object.attribute

基本语法：delattr(object,attribute)

type()该函数返回object类型。

基本语法：type(object)

dir()该函数返回取自活动名字空间的属性名称列表。object可以是任何类型。

基本语法：dir([object])

callable()如果object可调用，该函数返回1；否则返回0.

基本语法：callable(object)

hash()该函数返回object散列值。

基本语法：hash(object)

id()该函数返回object的系统唯一标识符

基本语法：id(object)

var()该函数返回object的符号表或局部名字空间列表。

基本语法：vars([object])

数学/逻辑函数

abs()该函数返回number的绝对值

基本语法：abs(number)

cmp() x<y时该函数返回-1；x==y时返回0，x>y时返回1.

基本语法：cmp(x,y)

round()该函数把number舍入到给定decimals。注意，该函数把拟舍数值默认舍入成整数。

基本语法：round(number[,decimals])

divmod()该函数返回元组（商，余数），生成表达式dividend/divisor

基本语法：divmod(dividend,divisor)

>>>divmod(25,3)===>(8,1)

代码函数

eval()该函数把编译代码string对象当做python代码那样进行评价，并返回评价结果。global和locals定义该操作的名字空间。注意，eval只能评价表达式，而不是任何语句。因此，eval('import string')无法运行。

基本语法：eval(string[,globals[,locals]])

>>>eval('2*y+(20/x)')

exec()该函数执行包含python代码的一个string。globals和locals定义该操作的名字空间。

基本语法：exec(string[in globals[,locals]])

>>> a='for b in range(4):\n print b,\n'

>>> exec a ===> 0 1 2 3

execfile()该函数执行所提供的file中包含的语句。globals和locals定义该操作的名字空间。

基本语法：execfile(string[,globals[,locals]])

>>> globalsvar={'x':7}

>>> execfile("c:\scriptename.py",globalsvar)

compile()该函数编译可选择性地位于一个file中的代码对象。type值取决于：如果string是语句序列，type是“exec”；如果string是大哥表达式，type则是“eval”；如果string是可执行的语句，type则是“single”

基本语法：compile(string,file,type)

类型转换

int()该函数把object转换成整数。

基本语法：int(object)

long()该函数把object转换成长整数。

基本语法：long(object)

float()该函数把object转换成浮点数

基本语法：float(object)

complex()该函数生成（real_imaginary)形式的复数。

基本语法：complex(real[,imaginary])

str()该函数返回object的可打印表示。其返回值与“print object”语法返回的值相同。

基本语法： str(object)

repr()该函数等价于一对反向引号``。repr()返回可评价的表达式。

基本语法：repr(object)

>>> repr('span\n) ===>'span\\012'

tuple()该函数创建基于sequence的元组。

基本语法：tuple(sequence)

list()该函数创建基于sequence的列表。

基本语法：list(sequence)

chr()该函数把integer转换成字符。

基本语法：chr(integer)

ord()该函数返回string的ASCII值

基本语法：ord(string)

hex()该函数把object转换成十六进制值

基本语法：hex（object）

oct()该函数把object转换成八进制值

基本语法：oct(object)

unicode()该函数获取一个8为字符串并生成一个单码字符串。

基本语法：unicode(string[,encoding][,error])

编码（encoding）和错误（errors）是我们还可以提供给该函数的一些附加变元。首变元是指encoding使用的字符串。error定义当前编码使用无效字符时该做什么。这里有说那个可选值：

strict表示一遇到编码错误就引发异常；ignore简单的忽略任何错误；replace则表示只要发现问题就使用正式替换字符U+FFFD代替无效字符。

unichr()该函数返回包含给定字符的1长度单码字符串。

基本语法：unichr(character)

14、python控制语句

(1)if/elif/else

(2)for 语句

for variable in sequence:

pass

else:

pass

只有根本没有执行for语句时或执行完最后一个循环后才执行else子句。换言之，除非在循环内部执行break语句，否则总执行else语句。

(3)while 语句

while <condition>:

pass

else:

pass

只有根本没有执行while语句时或执行完最后一个循环后才执行else子句。换言之，除非在循环内部执行break语句，否则总执行else语句。

（4）break/continue

break：

break子句终止循环，而且没有执行else子句。

continue

continue子句跳过循环体的其余部分，一直调回循环头。

15、python数据结构

a、列表

列表时可变的object序列，有创建后可变的自然数索引。

创建 >>> lst=[]

列表可有不同的数据类型的元素：类似于java的List<object> lst,所以列表也可以包含有其他的列表。

例如：lst=[1,"aa",[1,2,3]]

获取列表元素： lst[1] ====> "aa"

获取元素索引: lst.index("aa") ==>2

列表赋值： lst[1]="aa" 列表片赋值：lst[1:2]=["aa",[1,2,3]]

列表插入值：lst.insert(4,val)

列表删除值： del lst[4]

列表综合：也就是列表的元素从另一个列表计算而得，从而生成新的列表。从左向右评价并迭代所有for...in子句。

这意味着结果列表时给定序列的笛卡尔积。

[expression for expresion1 in sequence1

[for expression2 in sequence2]

[...for expressionN in sequenceN]

[if condition]

例如：

>>>letters="py"

>>> number=(1.52,1.5.2.0)

>>>[(1,n) for l in letters for n in numbers]

       列表内置方法：>>> dir([])
       ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delsli
       ce__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getit
       em__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
        '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__r
       educe__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__'
       , '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'a
       ppend', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'
       ]

b、值域

值域是整数的实际列表。内置函数range()提供这一数据类型。省略第一个变元时，假定它是0

xrange()返回一个XrangeType对象，而不是在变量中存储大型数字列表。可以通过toList()方法把该引用转换成实际的列表

也就是说range(5)等价于xrange(5).toList()

c、元组

元组是不可变python对象组成的序列

创建 tuple=()

获取元组元素： tuple[0]

函数返回多个值需要用元组。例如：

def f():

retrun 0,1,2

x,y,z=f()

元组内置函数：>>>dir(())

       ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__
       format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__get
       slice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__
       lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__'
       , '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count
       ', 'index']

d、字典（散列表）（关联数组）

字典是python中仅有的映射类型。字典键值不能使可变类型变量，键值是根据值而不是对象身份进行比较。

创建：dict={} 键值必须是不可变数据类型（如字符串，数值或元组）

获取对应键的值： dict["fish"]

删除元素： del dict["fish"]

内置函数：>>> dir({})

       ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__'
       , '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
        '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '_
       _new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__'
       , '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get
       ', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'po
       pitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues']

16、函数和过程

函数和过程是可以从代码的几个不同部分进行访问的代码块。

过程是不返回值的函数。函数和过程之间的唯一差别就是过程拥有一个不带变元的返回命令或者不包含任何任何语句。

执行函数时，函数创建自己的名字空间

函数调用过程：

a、python在其名字空间内部执行搜索，查找用于识别这是否是python对象的function

b、python生成有传递arguments组成的元组。

c、python内调用函数的方式apply(function,arguments)

由上可以看出，python中可以把函数名称与参数分割开来，把它们保存在某处并进行操作，然后使用apply内置函数执行该函数。

函数定义：

函数总以缩略字def开始。函数结束则由下面的随缩进代码块的最后行定义。

def fun_name(arg1,arg2...):

func_body

无变元函数的调用必须使用空括号。

可以向变量分配函数。例如 >>>x=abs >>>x(-2)===>2

python使用动态名字空间。每一个函数，模块以及类在创建时定义自己的名字空间。

向python通知指令，命令或者语句时，python首先搜索局部名字空间，然后搜索全局名字空间。

python具有如下几类名字空间：

内置名称----int、string、def、print等等

全局名称----在模块顶层声明成全局并加以赋值

局部名称----在函数内部赋值

在函数内部获得赋值的变量总属于函数的名字空间。

       >>> x=10                         >>> x=10
       >>> def ff():                           >>> def dd():
       ...     x=20                          ...     global x
       ...     return x                        ...     x=20
       ...                                     ...     return x
       >>> print ff()                         >>> print dd()
       20                                      20
       >>> print x                             >>> print x
       10                                      20

python通过提供有关键字lambda来实现匿名函数，lambda只是def的另一种书写形式而已，而且在其中只能防止一个表达式（返回时隐式的）。实际上lambda旨在提供使小型函数书写的简写方式。

参数

python语言中的所有参数（变元）都有引用传递。模块，类，实例以及其他函数可用做函数变元并可动态查看。

因为采用引用传递，作为变元传递到函数的可变对象在函数内部改变时，他们的外部值也相应改变。

python还提供命名变元。例如：def dd(port=0): pass 命令变元可以作为默认变元，也就是说产生默认值。

在我们无法预先查明可能需要的变元个数。可在类变元名之后使用专用符号*和**。*args以接受顺序获取值元组；而**args获取字典映射

函数的内置方法

       >>> def f():
       ...     pass
       >>> dir(f)
       ['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr_
       _', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globa
       ls__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__'
       , '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subcla
       sshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc'
       , 'func_globals', 'func_name']

模块和包

模块指文本文件中保存的类、函数以及变量等组成的集合。

在python应用程序中引用一个函数时，无需指定文件后缀----程序文本文件必须带有一个.py扩展名。模块可以由python或c编写。无论选择哪种语言编写模块，都可以使用相同语法调用两类模块。

下述语法为模块导入并创建全局名字空间：

import <module>

也可以只使用如下所示的导入语句同时导入多个模块：import m1,m2,m3

提示：第一次导入模块时执行所有代码

有些模块一直存在于python中。其他模块则是文件并需要导入（在大部分情况下，这些文件都拥有.py或.pyc后缀).为了导入，文件必须保存在sys.path变量中所列出的某一个目录之下。

包是位于同一目录下的模块集合。包名必须是sys.path变量中所列出的其中一个目录的子目录。

包目录至少必须拥有一个__init__.py文件。如果包中包含子包（子目录）。每个子目录也至少需要一个__init__.py文件

import a.b表示导入包a内部的子模块b。

导入包时，其子包并不随同一并导入。必须在__init__.py文件中明确说明。