【学习笔记】python语法笔记

基础操作

中文编码

# -*- coding:utf-8 -*-#

注释

#

列表和元组

序列操作

索引

>>>'Hello'[-1]
    'o'
>>>'Hello'[1]
    'e'

>>>fourth=input('Year: ')[3]
    Year: 2005
>>>fourth
    ‘5’

切片

tag[32:-4]//左闭右开
//注：若a1在a2索引位置后面，则结果为空序列[a1:a2]

步长

>>>number[0:10:2] //左->右
>>>number[8:3:-1] //右->左

相加

列表

>>>[1,2,3]+[4,5,6]

字符串

>>>‘Hello’+'world'

相乘

>>>'python'*5
>>>[42]*10

成员资格

>>>permissions='rw'
>>>‘w’in permission
    True

列表

字符串与列表的转换

字符串到列表

list('    ')

列表到字符串

'    '.join(some list)

赋值

x[1]=2

删除

del names[2]

特殊赋值删除方式

切片赋值

name[2: ]=list('ar')//在第3个元素开始

代替插入

numbers[1:1]=[2,3,4]

代替del

numbers[1:4]=[    ]

列表方法

append（将对象附加到末尾）

lst.append(4)

clear

lst.clear()

copy

b=a //同一个指向
b=a.copy

count

x.count(1)

extend(附多个值到列表末尾)

a.extend(b)//效率大于a=a+b(使用a、b的副本创建新的列表)

index

knights.index('who')

insert

numbers.insert(3,'four')//在第4个元素前插入

pop

>>> x.pop() //删除（弹出）末尾

remove

>>> x.remove('be')//就地修改不返回值

reverse

>>> x.reverse()

sort(升序排列)

sorted(x)//获取排序后的列表副本

高级排序

x.sort(key=len)

元组

>>> tuple([1,2,3])  //列表到元组
    (1,2,3)

访问

>>> x[0:2]
    (1,2)

字符串

替换

% + 元组（同c中printf）

>>> format="Hello,%s,%s enough for ya"
>>> value=('world','Hot')
>>> format % values
    "Hello,world,Hot enough for ya?"

关键字参数(同Unix shell)

>>> from string import Template
>>> tmpl=Template("Hello,$who!$what enough for ya?")
>>> templ.substitute(who="Mars",what="Dusty")
    "Hello,Mars!Dusty enough for ya?"

format

>>> "{0},{1} and {2}".format("first","second","third")
    'first,second and third'

命名字段

>>> from math imort p;
>>> "{name} is approximately {value:2f}".format(value =pi,name="pi")
    "pi" is approximately 3.14

混合使用

>>> "{foo} {1} {bar} {0}".format (1,2,bar=4,foo=3)
    '3 2 4 1'

宽度，精度，千位分隔符

宽度

>>>"{num:10}".format(num=3)
    '            3'

精度

>>>"pi day is {pi:2f}".format(pi=pi)
    'pi day is 3.14'

千位分隔符

>>> 'One googol is {:,}'.format (10*100)
    'One google is 10,000,000,...,000'

符号，对齐和用0填空

0填空

>>> '{: 010.2f}'.format(pi)//0:用0填空，10:宽度，2f：精度
    '0000003.14'    

左对齐，居中对齐，右对齐

>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi))
    3.14
        3.14
            3.14

方法

center 字符串剧中两边填充字符

>>> "The middle by Jimmy Eat World".center(39,"*")
    '***** The middle by Jimmy Eat World *****'

find 查找子串

>>> title ="Monty Python's Flying Circus"
>>> title.find ('Monty')
    0

join (合并字符串列表（防御参数字符串后）)

>>> dirs='    ','usr','bin','env'
>>> '/'.join(dirs)
    '    /usr/bin/env'

>>> Print('c:'+'\\'.join(dirs))
    c:\usr\bin\env

lower 返回字符串 小写版本

>>> 'Trondheim Hammer Dance'.lower()
    'trondheim hammer dance'

replace 替换

>>> 'This is a test'.replace('is','eez')
    'Theez eez a test'

split 将字符串拆分为序列

>>> '1+2+3+4+5'.split('+')
    ['1','2','3','4','5']

strip (删除字符串开头末尾空白)

>>>'    internal whitespace is kept    '.strip()
    'internal whitespace is kept'

translate (单个字符替换，同时替换多个字符)

>>> table =str.maketrans('cs','kz',' ')//maketrans(建表)，k代替c,z代替s，删除‘    ’
>>> 'this is an incredible test'.translate(table)
    'thizizaninkredibletezt'    

字典

列表：通过编号来访问各值
字典：通过名称访问各值的数据结构

创建

phonebook='{'Alice':'2341','Beth':'9102'}//'Alice':键(独一无二)，'2341'：项

dict

从其他映射或建一值对序列 创建字典

>>>[('name','gumby'),('age,42')]
>>>d=dict(items)
>>>d['name']
'gumby'

关键字实参

>>>d=dict(name='gumby',age=42)

基本行为

• len(d)
• d[k]
• d[k]=v
• del d[k] k in d

注:
1.自动添加（不像列表须使用append）
2.成员资格
k in d 字典到键
v in l 列表到值

字符串格式设置功能用于字典

>>>phonebook
{'Beth':'9102','Alice':'2341','cecil':'3258'}
>>>''Cecic's phone number is{cecil}''
format_map(phonebook)
''cecil's phone number is 3258''

字典方法

clear

d .(clear)//通过赋值字典是无法清除的

copy 浅复制（值可替换不可修改）值本身是原件而非副本

deepcopy 深复制

from keys 创建新字典

>>>dict.fromkeys(['name','age'])
{'age':None,'name':None}

get (项不在字典中也不会报错)

>>> print d.get('name')
None

items (返回一个包含有所有字典项的列表)

d.items()//字典项在列表中排序不确定 注：items() ->返回字典视图（不复制而是反映底层字典）

复制：

>>>list(d.items())

key 返回字典视图，包含字典中的键。

pop 获取与指定键相关值并删除（弹出）

>>>d={'x':1,'y':2}
>>>d.pop('x')
1
>>>d
{'y':2}

popitem

随机弹出一个字典项（高效逐个删除）

setdefault

字典中包含键时更新键-值对

update

若键相同，则替换

values

返回由值组成的字典视图，可重复

条件循环

打印多个参数

定义分隔符

>>>print("I","with","to",sep="_")

自定义结束字符串，替换默认的换行符

>>>print(hello,end=" ")
>>>print("world！")

导入

import  somemodule
or from somemodule import some function
or from somemodule import *
or import somemodule as XX

赋值

序列解包

>>>ralne=1,2,3
>>>x,y,z=valne
(*)收集多余值
>>>a,b,*rest=[1,2,3,4]
>>>rest
[3,4]

链式赋值

x=y=somefunction()

条件

布尔假：

• False
• None
• 0
• " "
• ()
• []
• {}

num=int(input('enter a number:'))
if num>0:
    print()//空四个空格
elif num<0:
    print()
else:
    print()

比较

• x==y
• x<y
• x>y
• x>=y
• x<=y
• x!=y
• x is y
• x is not y
• x in y
• x not in y

布尔运算符

• and
• or
• not

断言

>>>age=-1
>>>assert 0<age<100,'The age must be realistic'
//等同 if not condition 
				crash program

循环

while

x=1
while x<=100：
	print(x)
	x+=1

for（根据需求定制）

words=['this','is','an','ex','parrot']
for word in words
	print(word)

遍历特定范围的数range（0,100）（左闭右开）

选代时获取索引——值对 enumerate

for index,string in enumerate(string)//index:索引,string:值
	'xxx' in string:
	strings [index]='[censored]' 

while Tme——break

跳出循环

break——else

正常结束的情况

推导（从其他列表创建列表）

>>>[xxx for x in range(10)]
>>>[(x,y) for x in range(3) for y in range(3)]

等同于

result=[ ]
for x in range (3):
	for y in range (3)
		result.append((x,y))

pass 、del、 exec

pass

等同于‘{ }’

del 删除名称，并不能删除指向的值（还在内存中）

值无用后由python 解释器自动删除

exec（执行python语句) eval(返回python表达式的值)

设置命名空间避免变量被污染

>>>from math import sqrt 
>>>Scope={}     //字典
>>>exec('sqrt=1',scope)
>>>scope['sqrt']

抽象

def

def hello(name):
return'hello',+name+'!'

编写文档

def square(x):
	'Calculates the square of the number x'
	return x*x

访问

1.>>>square._doc_
2.>>>help(square)

注：当return没有返回值时返回None。
注：对序列执行切片，返回切片是副本。

>>>n=name[:]

关键字参数和默认值

>>>store(patient='Mr.',hour=10,munite=20)

def hello_3(greeting='hello',name='world')
	print('{},{}!':format(greeting,name))

收集参数 （提供任意参数）

def print_params (* params）:
	  print (params)

(* 创建元组，将结果放在元组中）
收集关键字参数

>>>def print_params_3(**params):
>>>print(paramas)
>>>print_params_3(x=1,y=2,z=3)
{'z'=3,'x'=1,'y'=2}

分配参数

*: 分配元组
**: 分配字典
注意 ：声明和调用最好不同时使用

作用域（命名空间）

globals( ):全局变量（局部变量会遮盖全局变量）
vars( ):作用域（看不见的字典）

抽象二（多态，封装，继承）

多态（同一函数，不同对象，不同行为）

（内置运算符和函数大量使用了多态）
Python编程方式的核心（可能并不有意为之）

类

创建

_metaclass_=type # python 2
class person:
	def set_name(self,name):
		self_name=name

调用

>>>foo=person()
>>>foo.set_name('luke skywalker')

外部可以访问属性

>>>foo.name
>>>'luke skywalker'

封装

使用方法或属性成为私有：_ _

class Secretive
	def_ _ inaccessible (self):
		print(" ")

外部访问私有：_类名 ：

>>>s._Secrective_ _in a<cessible

函数vs方法

函数 def methocl(self) （类中 参数关联到所属实列）
方法 def funcion() (不在类中)

命名空间

def foo(x): return x*x

等同于

foo=lambda x:x*x

所有代码在类的命名空间（特殊）内执行

class MemberCounter:
  	members=0        (相当于 ptublic static)
	def init(self):
		MemberCounter.members +=1   (同static概念)
		\\(MemberCounter:类命名空间中的变量由类实例共享,等同于类中的全局变量)

继承（子类）

class SPAMFilter (Filter)

可用函数：

• issubclass
• bases
• isinstance

>>>is subclass (SPAMFilter,Filter)//SPAMFilter：子，Filter：父（超类）
>>>SPAMFilter._bases_
>>>isinstance(s,Filter)//s：实例，Filter：类

多个超类

class Talking Caloulation(Calculator,Talker) 
	pass
(注：慎用，顺序决定同种方法名的覆盖)

异常

raise 引发异常

>>>raise Exception ('hyperdrive overload')  //内置异常类

自定义异常类 （对错误进行处理）

class SameCustomException(Exception):pass  //Exception：继承

捕获异常

try:
  ......
except ZeroDivisonError:
  ......

继续向上传播：

ecept ZeroDivision Error:
	if  self.muffled:
 	  print('Division')
	else:
	  raise

捕获多个异常

try:
...
except (ZeroDivisionError,TypeError):
...

访问异常本身并继续运行

except (Zero Divisionzmor,Type Error)as e:
	print(e)

finally

用于发生异常时执行清理工作

魔法（特殊）方法、特性、迭代器

python2->python3

metaclass=type

构造函数

class Foobar:
	def_init_(self):
		self.somevar=42
>>>f=Foobar()

等同于

>>>f=Foobar()  //分配内存
>>>f.init            //创造

子类构造函数

未关联的方法（由类调用 ）

class SongBird(Bird):
	def_init_(self):
		Bird_init_(self)
		self.sound='Squawk!'

Super (新式类，返回所需的超类)

class SongBird(Bird):
	def _init_(self):
		super()._init_()
		self.sound='squank!'

可变对象需要实现4个基本行为（协议）

• len(self)
• getitem(self,key):
• setitem(self,key,value)
• delitem(self,key)

property (避免重复代码，通过存取方法定义，使假象属性变为属性)

class Reetangle:
	def _init_ (self):
		self.width=0
		self.height=0
def set_size(self,size):
	self.width,self.height=size
size=property (get_size;set_size)

迭代器

class Fibs:  (斐波那契)
	def _init_(self):
		self.a=0
		self.b=1
def _next_(self):
	self.a,self.b=self.b,self.a+self.b
	return self.a
def _iter_(Self):
	return self // (self:迭代器)

应用

>>>fibs=fibs()
>>>for f in fibs://开始迭代
>>>if f>1000
>>>break

生成器

yield

def flatten(nested):
	for Sublist in nested:
		for elememt in Sublist:
			yield element
>>>nested =[[1,2],[3,4],[5]]
>>>for num in flatten (nested):
		frint(num)
//生成多个值，每次一个

---

• Doraengineer’s blog说明