您现在的位置是：首页 > Python

当前栏目

python总结

Python 对象

2023-02-26 12:36:04 时间

1 字符串

单引号（'）  
你可以用单引号指示字符串，就如同'Quote me on this'这样。所有的空白，即空格和制表符都照原样保留。  
双引号（"）  
在双引号中的字符串与单引号中的字符串的使用完全相同，例如"What's your name?"。  
三引号（'''或"""）  
利用三引号，你可以指示一个多行的字符串。你可以在三引号中自由的使用单引号和双引号。   
自然字符串  
如果你想要指示某些不需要如转义符那样的特别处理的字符串，那么你需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by\\n"。   
Unicode字符串  
Unicode是书写国际文本的标准方法。Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。  
记住，在你处理文本文件的时候使用Unicode字符串，特别是当你知道这个文件含有用非英语的语言写的文本。  
字符串是不可变的  
按字面意义级连字符串  
如果你把两个字符串按字面意义相邻放着，他们会被Python自动级连。例如，'What\\'s'  'your name?'会被自动转为"What's your name?"。   
  
给正则表达式用户的注释  
一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。例如，后向引用符可以写成'\\\\1'或 r'\\1'。   
  
2 对象  
记住，Python把在程序中用到的任何东西都称为 对象 。这是从广义上说的。因此我们不会说“某某 东西”，我们说“某个 对象 ”。  
给面向对象编程用户的注释  
就每一个东西包括数、字符串甚至函数都是对象这一点来说，Python是极其完全地面向对象的

3 逻辑行与物理行  
物理行是你在编写程序时所 看见 的。逻辑行是Python 看见 的单个语句。Python假定每个 物理行 对应一个 逻辑行 。  
默认地，Python希望每行都只使用一个语句，这样使得代码更加易读。  
如果你想要在一个物理行中使用多于一个逻辑行，那么你需要使用分号（;）来特别地标明这种用法。分号表示一个逻辑行/语句的结束。例如：  
i = 5  
print i  
与下面这个相同：  
i = 5;  
print i;  
同样也可以写成：  
i = 5; print i;  
甚至可以写成：  
i = 5; print i  
强烈建议你坚持在每个物理行只写一句逻辑行。仅仅当逻辑行太长的时候，在多于一个物理行写一个逻辑行。  
明确的行连接:在多个物理行中写一个逻辑行  
s = 'This is a string. \\  
This continues the string.'  
print s  
它的输出：  
This is a string. This continues the string.  
类似地，  
print \\  
i  
与如下写法效果相同：  
print i  
暗示的行连接，可以使你不需要使用反斜杠。这种情况出现在逻辑行中使用了圆括号、方括号或波形括号的时候。

4 缩进

同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。   
不要混合使用制表符和空格来缩进

5  运算符优先级

<table> 
 <tbody> 
 <tr> 
 <td>lambda</td> 
 <td>Lambda表 达式</td> 
 </tr> 
 <tr> 
 <td>or</td> 
 <td>布尔“或”</td> 
 </tr> 
 <tr> 
 <td>and</td> 
 <td>布尔“与”</td> 
 </tr> 
 <tr> 
 <td>not x</td> 
 <td>布尔“非”</td> 
 </tr> 
 <tr> 
 <td>in，not in</td> 
 <td>成员测试</td> 
 </tr> 
 <tr> 
 <td>is，is not</td> 
 <td>同一性测试</td> 
 </tr> 
 <tr> 
 <td>&lt;，&lt;=，&gt;，&gt;=，!=，==</td> 
 <td>比较</td> 
 </tr> 
 <tr> 
 <td>|</td> 
 <td>按位或</td> 
 </tr> 
 <tr> 
 <td>^</td> 
 <td>按位异或</td> 
 </tr> 
 <tr> 
 <td>&amp;</td> 
 <td>按位与</td> 
 </tr> 
 <tr> 
 <td>&lt;&lt;，&gt;&gt;</td> 
 <td>移位</td> 
 </tr> 
 <tr> 
 <td>+，-</td> 
 <td>加法与减法</td> 
 </tr> 
 <tr> 
 <td>*，/，%</td> 
 <td>乘法、除法 与取余</td> 
 </tr> 
 <tr> 
 <td>+x，-x</td> 
 <td>正负号</td> 
 </tr> 
 <tr> 
 <td>~x</td> 
 <td>按位翻转</td> 
 </tr> 
 <tr> 
 <td>**</td> 
 <td>指数</td> 
 </tr> 
 <tr> 
 <td>x.attribute</td> 
 <td>属性参考</td> 
 </tr> 
 <tr> 
 <td>x[index]</td> 
 <td>下标</td> 
 </tr> 
 <tr> 
 <td>x[index:index]</td> 
 <td>寻址段</td> 
 </tr> 
 <tr> 
 <td>f(arguments...)</td> 
 <td>函数调用</td> 
 </tr> 
 </tbody> 
</table>

(experession,...)  绑定或元组显示  
\[expression,...\] 列表显示  
\{key:datum,...\} 字典显示  
'expression,...' 字符串转换  
  
  
6 语句

在 while 循环中使用一个 else 从句。

while False:
        print 'False'
    else:
        print 'while...else'

for..in 循环对于任何序列都适用。 else 部分是可选的。如果包含else，它总是在 for 循环结束后执行一次，除非遇到 break 语句。

使用同一个 global 语句指定多个全局变量。例如 global x, y   
默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的   
只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。   
关键参数 ——使用名字（关键字）而不是位置来给函数指定实参。   
没有返回值的 return 语句等价于 return None 。  None 是Python中表示没有任何东西的特殊类型。   
每个函数都在结尾暗含有 return None 语句。通过运行 print NoReturn() ，你可以明白这一点

def NoReturn():
        pass
    print NoReturn()

7  DocStrings   
  
文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。

使用 \_\_doc\_\_ （注意双下划线）调用 函数的文档字符串属性（属于函数的名称）。   
help() ，那么你已经看到过DocStings的使用了！它所做的只是抓取函数的 \_\_doc\_\_ 属性，然后整洁展示。

pydoc命令，与 help() 类似地使用DocStrings。

8 模块

sys.argv 变量是一个字符串的 列表 （列表会在后面的 章节 详细解释）。特别地， sys.argv 包含了 命令行参数 的列表，即使用命令行传递给你的程序的参数。   
脚本的名称总是 sys.argv 列表的第一个参数。   
模块的\_\_name\_\_  
 每个模块都有一个名称，在模块中可以通过语句来找出模块的名称。当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，可以通过模块的\_\_name\_\_属性完成。

#!/usr/bin/python
    # Filename: using_name.py
    if __name__ == '__main__':
    print 'This program is being run by itself'
    else:
    print 'I am being imported from another module'

内建的 dir 函数来列出模块定义的标识符。标识符有函数、类和变量。

>>> a = 5
    >>> dir()
    ['__builtins__', 'a', 'sys']
    >>> del a
    >>> dir()
    ['__builtins__', 'sys']

del 语句在运行后被用来 删除 一个变量/名称。   
  
  
  
9  数据结构

元组和字符串一样是 不可变的    
含有0个或1个项目的元组。 一个空的元组由一对空的圆括号组成，如 myempty = () 。然而，含有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。

元组之内的元组不会失去它的身份。  同样元组中的元组，或列表中的元组，或元组中的列表等等都是如此。只要是Python，它们就只是使用另一个对象存储的对象。

>>> str = ('aa', 'bb', 'cc')
    >>> new = ('dd', 'ee', str)
    >>> len(new)
    3
    >>> print(new)
    ('dd', 'ee', ('aa', 'bb', 'cc'))
    >>> new[2]
    ('aa', 'bb', 'cc')
    >>> new[2][2]
    'cc'

元组最通常的用法是用在打印语句中

>>> name = 'zhai'
    >>> age = 20
    >>> print '%s is %d years old' % (name, age)
    zhai is 20 years old

只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。   
记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。  
字典是 dict 类的实例/对象。

可以使用 in 操作符来检验一个键/值对是否存在，或者使用 dict 类的 has\_key 方法。

if 'Guido' in ab: # OR ab.has_key('Guido')

列表、元组和字符串都是序列，序列的两个主要特点是索引操作符和切片操作符。序列的神奇之处在于可以用相同的方法访问元组、列表和字符串。

索引操作符让我们可以从序列中抓取一个特定项目。

切片操作符让我们能够获取序列的一个切片，即一部分序列。

当你创建一个对象并给它赋一个变量的时候，这个变量仅仅 参考 那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。

>>> str = ['aa', 'bb', 'cc']
    >>> ref = str
    >>> del ref[0]
    >>> print(str)
    ['bb', 'cc']
    >>> print(ref)
    ['bb', 'cc']
    >>> ref2 = str[:]
    >>> del ref2[0]
    >>> print(str)
    ['bb', 'cc']
    >>> print(ref2)
    ['cc']

需要记住的只是如果你想要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单 对象 ），那么你必须使用切片操作符来取得拷贝。   
记住列表的赋值语句不创建拷贝。你得使用切片操作符来建立序列的拷贝。   
  
10  面向对象的编程

域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称self，指对象本身。但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。

一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理

\_\_init\_\_ 方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。

类的变量      由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。  
对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。

Python不会自动调用基本类的constructor，你得亲自专门调用它。

raise 语句 引发 异常。还得指明错误/异常的名称和伴随异常 触发的 异常对象。可以引发的错误或异常应该分别是一个 Error 或 Exception 类的直接或间接导出类。

class ShortInputException(Exception):
 '''A user-defined exception class.'''
 def __init__(self, length, atleast):
 Exception.__init__(self)
 self.length = length
 self.atleast = atleast
 
 try:
 s = raw_input('Enter something --> ')
 if len(s) < 3:
 raise ShortInputException(len(s), 3)
 # Other work can continue as usual here
 except EOFError:
 print '\nWhy did you do an EOF on me?'
 except ShortInputException, x:
 print 'ShortInputException: The input was of length %d, \
 was expecting at least %d' % (x.length, x.atleast)
 else:
 print 'No exception was raised.'

sys.version 字符串给你提供安装的Python的版本信息。  sys.version\_info 元组则提供一个更简单的方法来使你的程序具备Python版本要求功能。

sys.stdin 、  sys.stdout 和 sys.stderr 它们分别对应你的程序的标准输入、标准输出和标准错误流。   
sys.argv 列表，它包含命令行参数。

if sys.argv[1].startswith('--'):
        option = sys.argv[1][2:]    # fetch sys.argv[1] but without the first two characters

在函数中接收元组和列表  
 当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用 \* 和 \*\* 前缀。这种方法在  
函数需要获取可变数量的参数的时候特别有用。

>>> def powersum(power, *args):
    ... '''Return the sum of each argument raised to specified power.'''
    ... total = 0
    ... for i in args:
    ... total += pow(i, power)
    ... return total
    ...
    >>> powersum(2, 3, 4)
    25
    >>> powersum(2, 10)
    100

由于在 args 变量前有 \* 前缀，所有多余的函数参数都会作为一个元组存储在 args 中。如果使用的是 \*\* 前缀，多余的参数则会被认为是一个字典的键/值对。   
  
lambda 语句用来创建函数对象。本质上， lambda 需要一个参数，后面仅跟单个表达式作为函数体，而表达式的值被这个新建的函数返回。注意，即便是 print 语句也不能用在lambda形式中，只能使用表达式。

exec和eval语句  
 exec 语句用来执行储存在字符串或文件中的Python语句。例如，我们可以在运行时生成一个包含Python代码的字符串，然后使用 exec 语句执行这些语句。

>>> exec 'print "Hello World"'
    Hello World

eval 语句用来计算存储在字符串中的有效Python表达式。

>>> eval('2*3')
    6

assert 语句用来声明某个条件是真的。例如，如果你非常确信某个你使用的列表中至少有一个元素，而你想要检验这一点，并且在它非真的时候引发一个错误，那么 assert 语句是应用在这种情形下的理想语句。当assert语句失败的时候，会引发一个 AssertionError 。

>>> mylist = ['item']
 >>> assert len(mylist) >= 1
 >>> mylist.pop()
 'item'
 >>> assert len(mylist) >= 1
 Traceback (most recent call last):
 File "<stdin>", line 1, in ?
 AssertionError

repr函数  
 repr 函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。注意，在大多数  
时候有 eval(repr(object)) == object 。

>>> i = []
    >>> i.append('item')
    >>> `i`
    "['item']"
    >>> repr(i)
    "['item']"

基本上， repr 函数和反引号用来获取对象的可打印的表示形式。你可以通过定义类的 \_\_repr\_\_ 方法来  
控制你的对象在被 repr 函数调用的时候返回的内容。

猜你喜欢

PHP面试题目搜集
PHP中MySQL操作
JavaScript与PHP中正则
赚点微信页面外快的一点记录
CSS3中border-radius、box-shadow与gradient那点事儿
JavaScript中尺寸、坐标
《HelloGitHub》第 13 期
grape动态PHP结构（三）——API接口
grape动态PHP结构（二）——管理后台
免费给自己的网站加 HTTPS
grape动态PHP结构（一）——目录结构与配置文件
微信公众平台开发（四）——微信支付
微信公众平台开发（三）——二维码、创建菜单
[Python Web]配置 nginx 遇到错误排查（初级）
微信公众平台开发（二）——access_token、日志
微信公众平台开发（一）——配置、请求
[Python]再学 socket 之非阻塞 Server
PC网站CSS分享
[Python]peewee 使用经验
windows配置xhprof，PHP性能分析工具

zl程序教程

当前栏目

python总结

相关文章