Python学习笔记与记录

学习Python的语法与用法记录

break语句：

    break用于将整个循环终止，当运行break后，循环将会跳出

    

continue语句：

    用于跳过continue后面的语句，直接进行下一次循环

    

pass语句：

        Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，

    一般用做占位语句。

Number：

        Number数据类型用于存储数值。和C/C++中的数据类型是一样的。不同之处在于

    python的变量类型不用声明，变量只有在赋值了以后才可以使用，才有意义。

    

    

用del语句删除一些 Number 对象引用。del语句的语法是：

    del var1[,var2[,var3[....,varN]]]

也可以通过使用del语句删除单个或多个对象，例如：

    del var

    del var_a, var_b

    

Python中的转义字符

-------------------------------------------

   转义字符        |        描述

-------------------------------------------

    \(在行尾时) |    续行符

    \\             |    反斜杠符号

    \'             |    单引号

    \"             |    双引号

    \a             |    响铃

    \b             |    退格(Backspace)

    \e             |    转义

    \000         |    空

    \n             |    换行

    \v             |    纵向制表符

    \t             |    横向制表符

    \r             |    回车

    \f             |    换页

    \oyy         |    八进制数，yy代表的字符，

                |    例如：\o12代表换行

    \xyy         |    十六进制数，yy代表的字符，

                |    例如：\x0a代表换行

    \other         |    其它的字符以普通格式输出

---------------------------------------------

Python中字符串格式化符号：

   符   号          描述

-------------------------------------------------

      %c     格式化字符及其ASCII码

      %s     格式化字符串

      %d     格式化整数

      %u     格式化无符号整型

      %o     格式化无符号八进制数

      %x     格式化无符号十六进制数

      %X     格式化无符号十六进制数（大写）

      %f     格式化浮点数字，可指定小数点后的精度

      %e     用科学计数法格式化浮点数

      %E     作用同%e，用科学计数法格式化浮点数

      %g     %f和%e的简写

      %G     %f 和 %E 的简写

      %p     用十六进制数格式化变量的地址

--------------------------------------------------

Python的三引号

    三引号可以将复杂的字符串进行复制

    允许一个字符串跨多行，字符串可以包含换行符、制表符

    以及其他特殊字符。

    

Python中的元组和列表

    列表和元组类似，和C/C++中的数组相似。列表和元组的

    不同之处在于元组元素不能修改而列表可以。

    其中：

    1.列表用[]表示，例如：list1 = ['physics', 'chemistry', 1997, 2000]

    2.元组用()表示，例如：tup1 = ('physics', 'chemistry', 1997, 2000);

Python的字典：

    字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值

    (key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典

    包括在花括号({})中 ,格式如下所示：

            d = {key1 : value1, key2 : value2 }

            

            

Python中的函数：

    可以定义一个由自己想要功能的函数，以下是简单的规则：

        1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

        2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

        3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

        4.函数内容以冒号起始，并且缩进。

        5.return [表达式] 结束函数，选择性地返回一个值给调用方。

        不带表达式的return相当于返回 None。

        可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

    不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，

    而 5 被丢弃，不是改变a的值，相当于新生成了a。

    可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第二个元素值更改，本身la

    没有动，只是其内部的一部分值被修改了。

    

    

Python 模块

    1.模块能够有逻辑地组织你的Python代码段。

    2.把相关的代码分配到一个 模块里能让代码更好用，更易懂。

    3.模块也是Python对象，具有随机的名字属性用来绑定或引用。

    4.简单地说，模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的

    代码。

    

    

    

读取键盘输入

Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：

    1.raw_input

    2.input

    

    

    

self代表类的实例，而非类

    类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

例：

class Test:

    def prt(self):

        print(self)

        print(self.__class__)

t = Test()

t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x10d066878>

__main__.Test

    从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的。

也可以使用以下函数的方式来访问属性：

    getattr(obj, name[, default]) : 访问对象的属性。

    hasattr(obj,name) : 检查是否存在一个属性。

    setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。

    delattr(obj, name) : 删除属性。

例：

    hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。

    getattr(emp1, 'age')    # 返回 'age' 属性的值

    setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8

    delattr(empl, 'age')    # 删除属性 'age

    

    

    

    

类的继承

    面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。

在python中继承中的一些特点：

    1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

    2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

    3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

方法重写

    如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

实例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent:        # 定义父类

   def myMethod(self):

      print '调用父类方法'

class Child(Parent): # 定义子类

   def myMethod(self):

      print '调用子类方法'

c = Child()          # 子类实例

c.myMethod()         # 子类调用重写方法

类属性与方法

类的私有属性

    __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

    在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

类的私有方法

    __private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods

    

    

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性。

网路编程

什么是 Socket?

    Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。

    

在python中发现，如果用    

for i in range(0, 5):

        print '*',

则输出的是 * * * * *

而用

for i in range(0, 5):

        print '*'

则输出的是     *

            *

            *

            *

            *

            

print后面没有写任何东西，是起到换行的作用

当函数有多个参数时，如果你想给部分参数提供默认参数，那么这些参数必须在参数的末尾

__name__和__main__的作用

如果用到

if __name__ == "__main__"

则可以用来判断当前执行的文件是否是本文件，__name__是当前文件的名字

声明：s为字符串，rm为要删除的字符序列

    s.strip(rm)       删除s字符串中开头、结尾处，位于 rm删除序列的字符

    s.lstrip(rm)      删除s字符串中开头处，位于 rm删除序列的字符

    s.rstrip(rm)      删除s字符串中结尾处，位于 rm删除序列的字符

    

    

可以在语句末尾增加一个as子句，在改子句后面给出名字，或为整个模块提供别名

    import math as foobar

    foobar.sqrt(4)

    

    

在函数中，参数前面放置星号※是将所有参数放在同一个元组中。也就是说可以定义多个参数。

    HttpResponse ，它是用来向网页返回内容的，就像 Python 中的 print 函数一样，只不过

 HttpResponse 是把内容显示到网页上。（其实是对数据的一个传递，这里为了简单理解，我们

 可以当做一个输出函数来看待。）

 

 

对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。

    但是对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有

内存中进行，从而影响原有变量。

生成器(generator)的主要目的是构成一个用户自定义的循环对象。

---------------------------------

f = open("new.txt", "w")

print(f.closed)             

f.write("Hello World!")

f.close()

print(f.closed)

=================================         这两段代码表示的含义是一样的

with open("new.txt", "w") as f:

    print(f.closed)

    f.write("Hello World!")

print(f.closed)

----------------------------------

    任何定义了__enter__()和__exit__()方法的对象都可以用于上下文管理器。文件对象f是内置对象，所以f自动带

有这两个特殊方法，不需要自定义。

capitalize()方法返回字符串的一个副本，只有它的第一个字母大写。对于8位的字符串，这个方法与语言环境相关。

hasattr(object, name)

    判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。

需要注意的是name要用括号括起来

getattr(object, name[,default])

    获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。

需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，

可以在后面添加一对括号。

setattr(object, name, values)

    给对象的属性赋值，若属性不存在，先创建再赋值。

    

    

callable(object)

中文说明：检查对象object是否可调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

-------

迭代器：

    是一个实现迭代协议的容器对象。他基于两个方法：

        · next 返回容器的下一个项目

        · _iter_ 返回迭代器本身。

    迭代器可以通过使用一个iter内建函数和一个序列来创建

-------

    

-------

生成器：

    带有yeild函数，使得需要返回一系列元素的函数所需的代码更加简单、高效。

基于yield指令，可以暂停一个函数并返回中间结果。该函数将保存执行环境

并且可以在必要时恢复

    yeild函数的作用是将数保存成一个列表list

    

    python引入的于生成器相关的最后一个特性是提供了于next方法调用的代码进行交互的功能。yeild将变成一个表达式，

而一个值可以通过名为send的新方法来传递。

item()

    item()方法把字典中每对key和value组成一个元组，并把这些元组放在列表中返回。

    例：

    s = {"name": "zhangsan", "address":"beijing"}

    def test():

        data = {}

        for k,v in s.items():

            print k, v

    test()

    

    输出结果为

    name zhangsan

    address beijing

    

Python lower() 方法转换字符串中所有大写字符为小写。

join用法：

    str1 = ["name","password"]

    str2 = "user"

    str3 = ""

    sql = 'select %s from %s %s limit 1' % ( ','.join(str1), str2, str3 )

    print sql

    输出的结果是：select name,password from user limit

    

    str1 = "name"

    str2 = "user"

    str3 = ""

    sql = 'select %s from %s %s limit 1' % ( ','.join(str1), str2, str3 )

    print sql

    输出的结果是：select n,a,m,e from user limit

    

    结论：(,)join可以将元组分开