【学习笔记】python语法笔记

素颜马尾好姑娘i 2022-03-18 15:06 421阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTM5NQ_size_16_color_FFFFFF_t_70]

# 基础操作 #

中文编码

# -*- 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说明][Doraengineer_s blog]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0MTM5NQ_size_16_color_FFFFFF_t_70]: /images/20220318/35e7bc411b0a4e6188ca83194d67e0ef.png
[Doraengineer_s blog]: https://blog.csdn.net/weixin_42641395/article/details/82558190