第1章：Python编程基础

变量和赋值语句

在同一条赋值语句中可以引入多个变量

交换变量 a 和 b 的值

a,b = b,a

Python换行可以使用转义字符 \，下一行的缩进量相同

product = max(100,200)\

*30

帮助文档

help()

控制语句

条件式语句

如果只有一条语句，可以不用换行

if 1 < 2:print('smaller')

模块测试语句

if __name__ == "__main__":

main()

字符串及其运算

运算符

"greater"[2:5] #Retruns "eat"

格式化字符串

格式

<formtt string> % <datum>

指定字符宽度以及左右对齐

示例1

print( "%6s" % "four" ) #右对齐

print( "%-6s" % "four" ) #左对齐

示例2

for exponent in range(7,11):

print( "%-3d%12d" % ( exponent, 10 ** exponent ) )

浮点数

%<field width>.<precision>f
precision 为小数点的精度
示例

salary = 100

print( "Your salary is $%0.2f." % salary )

对象和方法的调用

显示某一对象的所有方法

在 IDLE 中使用 dir 命令

示例

dir(str)

内建Python集合及操作

对集合应用模式匹配

模式匹配将一个结构赋值给另一个形式完全相同的结构

rgTuple = ( ( <r>, <g>, <b> ), <string> )

( ( r, g, b ), hexString ) = rgTuple

编写新的函数

递归函数

运行示例

def ourSum( lower, upper, margin = 0 ):

"""Returns the sum of the numbers from lower to upper,

and outputs a trace of the arguements and return values

on each call."""

blanks = " " * margin

print( blanks,str(lower)+ str(upper) )

if lower > upper:

print( blanks, 0 )

return 0

else:

result = lower + ourSum( lower + 1, upper, margin + 4 )

print( blanks,result )

return result

if __name__ == "__main__":

ourSum(1,4)

输出

嵌套函数的定义

示例

def factorial(n):

""" Returns the factorial of n. """

def recurse(n, product):

if n == 1: return product

else: return recurse(n-1, n * product)

return recurse(n, 1)

高阶函数

高阶函数接收一个函数作为参数，并且以某种方式应用该函数
map 函数

输入：一个函数和一个可迭代对象
输出：对可迭代对象的每一项应用参数函数，得到一个新的可迭代对象，并返回
示例

oldList = [1,2,3,4]

newList = list( map( str, oldList ) ) #Returns ['1', '2', '3', '4']

filter 函数

输入：一个布尔函数的一个可迭代对象
功能：对可迭代对象的每一项应用布尔函数，如果其为真，则将其加入到新的可迭代对象中。
示例

def isPositive( number ):

"""判断是否为正数"""

if number > 0: return True

else: return False

oldList = [-1,2,3,5,-100,1000,0]

newList = list( filter( isPositive, oldList ) ) #[2,3,5,1000]

使用 lambda 创建匿名函数

lambda <argument list> : <expression>
示例

newList = list( filter( lambda number : number > 0, oldList ) )

functools.reduce 高阶函数

功能：通过应用带有两个参数的函数来将一个可迭代对象转换为单个的值，该函数的两个参数是下一项和前一次应用该函数的结果
示例

import functools

product = functools.reduce( lambda x,y : x * y, range(1,6) ) #120

捕获异常

确保用户输入整数

def safeIntegerInput( prompt ):

"""Pormpts the user for an integer nad returns the

integer if it is well-formed. Otherwise, prints an

error message and repeats this process."""

inputString = input( prompt )

try:

number = int( inputString )

return number

except ValueError:

print( "Please Enter in the correct number format:", inputString )

return safeIntegerInput( prompt )

文件及其操作

使用 pickle 读写对象

可以直接对对象进行储存与读取操作
示例

import pickle

#写入文件

lyst = [60, "A string object", [1444, 1644, 1911] ]

fileObj = open( "items.dat", "wb" )

for item in lyst:

pickle.dump( item, fileObj )

fileObj.close()

#读取文件

lyst = list()

fileObj = open( "items.dat", "rb" )

while True:

try:

item = pickle.load( fileObj )

lyst.append( item )

except EOFError:

fileObj.close()

break

print( lyst )

创建新的类

所有的 Python 类都位于层级之中， object 在这个层级的根部
示例

class Counter(object):

"""Models a counter"""

# Class variable

instances = 0

# Constructor

def __init__(self):

"""Set up the counter."""

Counter.instances += 1

self.reset()

#Mutator methods

def reset(self):

"""Sets the counter to 0. """

self._value = 0

def increment(self, amount = 1):

"""Adds amount to the counter."""

self._value += amount

def decrement(self, amount = 1):

"""Subtracts amount from the counter"""

self._value -= amount

#Acessor methods

def getValue(self):

"""Return the counter's value."""

return str( self._value )

def __str__(self):

"""Returns the string representation of the counter."""

return str(self._value)

def __eq__(self, other):

"""Returns True if self equals other or False otherwise."""

if self is other: return True

if type(self) != type(other): return False

return self._value == other._value

类变量 instances

记录了所创建的 Counter 对象的数目
除了最初的赋值以外，在其他时候，类变量必须有一个类名作为其前缀

实例变量 self._value

加下划线的目的是为了便于区别

__str__

覆盖了 object 中的 str 函数

__eq__

相当于 ==

第1章：Python编程基础

猜你喜欢