【Python 之执行 py 文件】
1、在 cmd/shell 中输入命令 python a.py
2、在解释器中,通过函数 execfile("a.py") exec
语句用来执行储存在字符串或文件中的Python语句
3、在解释器中,直接输入程序语句立即执行
【Python 之退出解释器】
1、>>> import sys
>>> sys.exit()
2、通过引发异常:raise SystemExit
3、输入EOF字符,windows下是Ctrl+Z,unix下是Ctrl+D
-----------------------------------------------------
【Python 之数据类型】
:在 python 中有4种类型的数 - 整数,长整数,浮点数 和 复数
-----------------------------------------------------
【Python 之函数】:def foo(p1,p2,....):
1、Python 函数定义不需要头文件
2、Python 函数定义不需要指定返回值的类型,你要麽 return value,要麽让函数自己 return None Python的NULL值)
3、Python 中变量和函数参数都不需要指明类型,根据它们得到的值,Python 会自己维护它们的类型
4、Python 语言没有子程序或过程(VB 中的 sub),统统的一切都只是函数
5、文档字符串 “““docstring””” 必须在函数的第一个逻辑行被定义,文档字符串同样也适用于模块和类
6、调用函数时,可以通过形参位置和形参名称两种方法来给函数传递实参
7、pass 语句在 pyhon 中表示一个空的语句块
8、调用函数时会为局部变量引入一个新的符号表。所有的局部变量都存储在这个局部符号表中。
9、引用参数时,会先从局部符号表中查找,然后是全局符号表,然后是内置命名表。因此,全局参数虽然可以被引用,
但它们不能在函数中直接赋值(除非它们用global语句命名)
10、用户定义的函数名也是一个解释器认可的类型值。这个值可以赋给其它变量,使其能做为一个函数来使用
【Python 之 lambda 函数】:本质上 lambda 可以有任意数目的参数,冒号后面仅跟单个表达式作为函数体
定义:foo = lambda x:expression 相当于 def foo(x):expression
调用:foo(y)或直接(lambda x:expression)(y),x 形参,y 实参
1、lambda 函数不能包含任何命令,而且只能包含一句表达式
2、lambda 并没有必须要使用它的理由,使用它仅是一种风格
-----------------------------------------------------
【Python 之模块】
1、导入模块名用 import module_name; 导入模块中的一个子项目用 from module_name import xxx
2、访问模块内部的函数,类以及各种属性
3、要导入的模块应该被放置和调用它的程序相同的目录中,或者在 sys.path 变量所列目录之一
4、当你要导入一个模块时, Python 会依次在这些目录里寻找与你要导入的模块名称一致的 py 文件
5、并不是所有的模块都是以 py 文件存在的,比如内置模块,它们的 py 源代码并不可见,因为它们不是用 python 写成的
6、每个模块都有__name__ 属性,当模块是被导入使用时,它的值为模块名;而当模块是被直接运行时,它便是__main__
【Python 之对象】
1、字符串是对象,列表是对象,函数是对象,模块也是对象
2、Python 中对象的定义较宽松,即只要能赋予变量,或作为参数传递给函数的都能被视为对象
3、当你将一个对象赋予一个变量的时候,这个变量仅仅是这个对象的引用,也就是说,变量名指向存储这个对象的内存
: 所以当你把 a 列表赋给 b 列表的时候,你只是创建了另一个索引,而对其中任何一个的更改都会影响到另一个
: 如果你不想冒此风险,就必须通过切片 b =a[:]来完全复制一个链表再赋给 b,这样对 a 的更改就不会影响到 b
-----------------------------------------------------
Python中每个语句以换行结束,若要在一行中写多个语句,这时语句之间必须使用用分号分隔
Python语言使用缩进块来表示程序逻辑(其它大多数语言使用大括号等)
Python并未指定缩进的空白数目,唯一的要求是同一层次的语句必须有相同的缩进空白
(注意,要么都是空格,要么都是制表符,千万别混用)
【Python 之控制结构】-其中,1、2、3 语句后都需要带冒号:
1、if 语法为 if elif else
2、for 对于任何序列都适用,逐一使用序列中的每个子项目
3、while
4、break 与C中的作用相同,用于跳出最近的一级 for 或 while 循环
5、range() 生成一个等差级数链表
6、continue 与C中的作用相同,用于继续执行下一次迭代
6、else 子句 在循环结束后(for)或条件为False(while)时执行,但循环被break中止的情况下不会执行
7、pass 语句 pass 语句什么也不做,它用于那些语法上必须要有什么语句,但程序上什么也不要做的场合
-----------------------------------------------------
【Python 之数据结构】
-----------------------------------------------------
【Python 之字典】:无序集合,所以无法像链表那样,根据 排列序号 来索引元素或索引切片
创建:dict = {1:35,2:"nice","key":"ugly"}
索引:dict [1] #35 was acquired
修改:dict [1] = 36 #35 replaced by 36
添加:dict [3] = 47 #pair (3:47) was added
删除:del dict[1] #pair (1:35) was deleted
0、你只能使用不可变的对象(比如字符串)来作为字典的键
1、记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序,那么你应该在使用前自己对它们排序。
2、you can get values by key, but you can't get keys by value
4、字典中不能含有重复的键,对一个已存在的键赋值,只是简单地将原来的值替换
5、任何时候,你都可以向字典添加新的 key-value 对,但新添加值的出现位置是随机的
6、字典的元素之间没有顺序的概念,它们之间的排列完全是无序状态
7、字典的键是有大小写之分的,更重要的是字典的键是 immutable 的,所以它只能使用同样是 immutable 的类型
8、键的数据类型可以为字符串型,整型,tuple,list不行;而值可以是任何数据类型,包括字符串,整数,对象,甚至字典
9、字典的元素删除可以通过 del dict["key1"];字典的清空可以通过 dict.clear() -> {}仍是字典
10、keys( )返回一个无序的、包含所有键的列表;values( )返回一个有序的、包含所有值的链表;
items( )返回一个由 tuple(key,value) 组成的链表;
-----------------------------------------------------
【列表 <--> 字符串】
: str = "_".join(str_list),把str_list 内的每个元素都用‘_’ 连接成一个字符串
:list = str.split("_"),在str 中每遇到一个 ‘_’ 就切开,并将分离的字符串作为链表的一个元素
【Python 之字符串】
:这里没有像C里的字符类型,单个字符仅仅是长度为一的字符串
:python 字符串不能被改写,按下标或切片赋值均会失败
:单引号' '和双引号" "字符串是完全相同的,它们没有在任何方面有区别
:在单引号字符串中可直接使用双、三引号,在双引号字符串中可直接使用单引号,在三引号中可自由使用单、双引号
:在单,双引号字符串中使用同类引号,可以通过转义字符 \ 实现
:三引号""" """中的字符串被解释器打印出来的结果与它们输入的形式完全相同:内部的引号,用反斜杠标识的引号和各种怪字符,
都精确的显示出来。
:自然字符串通过在字符串前加 r 或 R 来指定;unicode 字符串通过在字符串前加 u 或 U 来指定
:字符串可以用+号联接,也可以用*号循环,但e = 'ab' 'cd'这种方式只对字符串值有效
【Python 之列表】:有序集合
创建 :list = [1,2,"a","b","mac"]
元素索引:list [4] -> 'mac' 或 list [ -1] -> 'mac' ,负索引公式 list [ -n ] = list [ len(list) - n ]
切片索引:list [1:3] -> [ 2,'a' ,'b' ] 或 list [-4:3] -> [ 2,'a' ,'b' ]
快捷切片:list [:n] -> 从开始到 list[ n-1];list [n:] -> 从 list[ n ] 个开始到结束
修改 :list [n] = 0;list [ m:n ] = [1,2.....]
添加 :不能像字典那样直接添加,因为链表是有序排列,需要位置信息,list.append( ),list.insert( ),list.extend( [ ] )
搜索下标:list.index("mac") -> 4,它只返回要搜索的元素在链表中第一次出现的位置
删除 :list.remove(element),它只删除第一个 element 的存在,不止一个存在的话就需要多次执行
0、列表可以包含任何数据类型!
1、测试某个元素是否在 list 中,用 in,如 ”mac" in list,根据结果它会返回 True 或 False
2、insert() 的参数可以是单个元素,也可以是一个 list,当是一个list 的时候,父 list 的长度只加1
3、extend ()的参数只能是一个 list,加上去之后父 list 的长度是随着子 list 的长度而相应增长的
4、pop()做两件事,删除最后一个元素的同时返回该元素
5、list = list + otherlist 得到的结果与 list.extend(otherlist) 同,但是+形成一个新的链表,而 extend 只是在原来的
链表上动态增长,所以 extend 的速度更快,特别是对于大的链表
6、list += otherlist 与 extend 同等
7、用于列表的 * 操作符是个起到重复的功能
8、列表的映射是将一个序列(list,tuple,dict)映射为另一个 list,所以整个表达式要用[]包含,比如 listb = [a*2 for a in lista]
【下标索引※切片索引】
:列表、tuple 和字符串都是序列,是序列就支持下标和切片索引
:字符串可以用下标查询,但如果超过了索引范围,就会出错
:切片操作符 s[a:b],a是闭环,b是开环,即返回的结果包含a,但不包含b
:要想包含最后一个元素,则冒号:后空着,不要指定b
:如果不指定第一个数,就从序列首开始。如果没有指定第二个数,则Python会停止在序列尾。
:返回的序列从开始位置开始,刚好在结束位置之前结束。即开始位置是包含在切片中的,而结束位置被排斥在切片外
:四种情况下,切片索引将返回空字符串(假设 a = "lucky")
1,下界超出上界,如 a[3:1] 或 a[-1:-3],但有种情况例外,如 a[1:-1]
2,上界等于下界,如 a[0:0] 或 a[-1:-1]
3,上下界均右溢,如 a[10:100]
4,上下界均左溢,如 a[-100:-10]
【Python 之Tuples】可以包含数字,字符串,列表,字典和另一个 tuple !
:tuple 是不可变的list,一旦创建了一个 tuple,就不能以任何方式改变它
:tuple 没有方法,不能增加、删除或查找元素,只能使用in查看是个元素是否存在于tuple
:tuple 之内的 tuple 不会失去它的身份,它仍然是个 tuple
:空的 tuple 用一对空的圆括号表示;单个元素的 tuple 必须在元素后加个逗号,用来区别带圆括号的对象
:元组最通常的用法是用在打印语句中,如 print '%s is %d years old' % (name, age)
相同点:
1、tuple 的创建和链表几乎一样,除了是使用圆括号而不是方括号,例如 tuple = (1,2,"a","b")
2、tuple 也是有序排列的,第一个元素也是从下标 0 开始
3、和链表一样,负索引也是从最后一个元素倒着开始的
4、切片功能和链表也一样,只不过list 的切片得到的仍是list, tuple 切片得到的仍是 tuple
5、tuple 和 list 之间可以相互转化,通过内置函数 tuple() 和 list()
不同点:
1、tuple 是 immutable 的,它不具有像list 的 append,extend,remove,pop,index 那些方法
2、然而,你可以像list 一样,使用 in 方法查看某个元素是否存在于 tuple 里面
3、tuple 可以被用作字典里的键,而list 却不可以,因为字典的键也是 immutable 的,两者是共同的
4、但是如果 tuple 里含有list,那该 tuple 就会被当作 mutable
何时选择 tuple:
访问 tuple 比 访问 list 更快,当你需要一个集合的同时又不需要去改变什么的时候
-----------------------------------------------------
【Python 之类与面向对象】
1、和C++不同,Python 类的所有函数在定义的时候必须显式给定一个形参,等价于 this,但在调用时却不必为它赋值
a、当你定义你自己的类方法时,必须明确将self作为每个方法的第一个参数列出,包括__init__()
b、当从你的类中调用一个父类的一个方法时,你必须包括self参数
c、当你从类的外部调用你的类方法时,不必对self指定任何实参,python会自动替你增加实例的引用
Python中对象方法的定义很怪异,第一个参数一般都命名为self(相当于其它语言的this),用于传递对象本身,而在调用的时候则不必显式传递,系统会自动传递。
举一个很常见的例子:
>>> class Foo:
def bar(self, message):
print(message)
>>> Foo().bar("Hello, World.")
Hello, World.
当存在继承关系的时候,有时候需要在子类中调用父类的方法,此时最简单的方法是把对象调用转换成类调用,需要注意的是这时self参数需要显式传递,例如:
>>> class FooParent:
def bar(self, message):
print(message)
>>> class FooChild(FooParent):
def bar(self, message):
FooParent.bar(self, message)
>>> FooChild().bar("Hello, World.")
Hello, World.
这样做有一些缺点,比如说如果修改了父类名称,那么在子类中会涉及多处修改,另外,Python是允许多继承的语言,如上所示的方法在多继承时就需要重复写多次,显得累赘。为了解决这些问题,Python引入了super()机制,例子代码如下:
>>> class FooParent:
def bar(self, message):
print(message)
>>> class FooChild(FooParent):
def bar(self, message):
super(FooChild, self).bar(message)
>>> FooChild().bar("Hello, World.")
Hello, World.
2、Python 类的构造函数是 __init__(),同样需要指定第一个参数 self,以后每次创建对象时,便自动初始化
3、Python 类的析构函数是 __del__(),当对象销毁的时候自动调用,如del a 或者a 不再代表这个对象
4、Python 类中的变量也称为域,类域相当于静态变量,在类定义之后定义,对象域相当于实例变量,在__init__中定义
5、类的变量由该类所有的对象共享,当某个对象对类的变量做了改动,就会反映到所有其他的对象上
>>> class D:
... v = [1,2]
...
>>> id(D.v)
13532856
>>> d=D()
>>> id(d.v)
13532856
>>> d.v.append(3)
>>> d.v
[1, 2, 3]
>>> id(d.v)
13532856
>>> D.v
[1, 2, 3]
6、对象的变量由某个对象私有,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是它们却互不相关。。。。。不对
>>> d2=D()
>>> d2.v
[1, 2, 3]
>>> d2.v.append(4)
>>> d2.v
[1, 2, 3, 4]
>>> d.v
[1, 2, 3, 4]
7、类的实例化MyObject=MyClass() - MyObject.method(a,b) - MyClass.method(MyObject,a,b)
8、Python不会自动调用基本类的constructor,你得亲自在定义子类的时候调用它
8、继承优点一:代码重用,不必重写父类的代码,也不必创建新类
9、继承优点二:对父类的修改可以自动反映到所有的子类
0、继承优点三:对子类的修改不会影响父类和其它的子类
0、继承优点四:子类的对象可以被当作父类的对象来使用,称为多态
0、如果在继承元组中列了一个以上的类,那么它就被称作多重继承
-----------------------------------------------------
【Python 之异常】
try :我们把所有可能引发异常的语句放在try块中,对于每个try从句,至少都有一个相关联的except从句
except :一个预定义的异常或自定义的异常类名及对象,或者一组包括在圆括号内的异常,如果没有特别给出,只要出现异常,
它就会用后面的代码来处理
raise :预定义的异常或自定义的异常类型,即一个Error 或 Exception 类的子类
finally :无论是否发生异常,finally 从句都会在程序退出之前被执行,
如果你想在一个 try 块下同时使用 except 从句和 finally 从句的话,需要把一个嵌入另外一个
-----------------------------------------------------
【Python 之数据转换】
tuple 和 list 之间可以相互转化,通过内置函数 tuple() 和 list()
string 和 list 之间可以相互转化,通过字符串函数join() 和 split(),但是 join 只能用于元素是字符串的list