def python 跳出函数 python跳出当前函数

1.

break语句：用于跳出最近的 for 或 while 循环。（不在执行循环）
continue语句：表示继续下一次迭代（跳出本次循环）
pass语句：相当于轮空

2

*函数接收参数为元组

例如

def myfun(*args): #相当于 def myfun(1,2,3) ==> args 就相当于（1,2,3）
for a in args:
 　　　　print(a)
 　　　　
 ** 表示函数接收参数为一个字典
 def myfun(**args) :#相当于 def myfun({a:1,b:2,c:3}) ==>args 就相当于{a:1,b:2,c:3}
 　　for k,v in args:
 　　　　print(k,":",v)

例子：

def conct(*args,sep='/'):
	sep.join(args)
conct('hello','world',sep=',')

输出：hello,world

3,lambda

下面是一些lambda函数示例：
lambda x, y: xy；函数输入是x和y，输出是它们的积xy
lambda:None；函数没有输入参数，输出是None
lambda *args: sum(args); 输入是任意个数的参数，输出是它们的和(隐性要求是输入参数必须能够进行加法运算)
lambda **kwargs: 1；输入是任意键值对参数，输出是1\

4.列表的特性（list）

• list.append(x)
  添加一个元素到列表的末尾。
• list.extend(L)
  将给定列表L中的所有元素附加到原列表a的末尾

def f():
    a=[]
    a.append('a')
    a.extend('we')
    print(a)
f()

输出：[‘a’,‘w’,‘e’]

• list.insert(i, x)
  在给定位置插入一个元素。第一个参数为被插入元素的位置索引，因此 a.insert(0, x) 在列表头插入值， a.insert(len(a), x)相当于 a.append(x).
• list.remove(x)
  删除列表中第一个值为 x 的元素,例如：a.remove(‘uu’)
• list.pop([i])
  删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop()将会删除并返回列表中的最后一个元素.例如：z=a.pop(0)
• list.clear()
  删除列表中所有的元素。相当于 del a[:].
• list.index(x)
  返回列表中第一个值为 x 的元素的索引。如果没有这样的元素将会报错。
• list.count(x)
  返回列表中 x 出现的次数。
• 列表作为栈使用

5.1.1. 列表作为栈使用
列表方法使得将列表用作堆栈非常容易，其中添加的最后一个元素是可提取的第一个元素（“last-in，first-out”）。使用 append()添加项到栈顶。使用无参的 pop() 从栈顶检出项。例如：

>>>
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

5.1.2. 列表作为队列使用
列表也有可能被用来作队列——先添加的元素被最先取出 (“先进先出”)；然而列表用作这个目的相当低效。因为在列表的末尾添加和弹出元素非常快，但是在列表的开头插入或弹出元素却很慢 (因为所有的其他元素必须向右或向左移一位)。

若要实现一个队列， collections.deque 被设计用于快速地从两端操作。例如：

from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")           # Terry arrives
queue.append("Graham")          # Graham arrives
queue.popleft()                 # The first to arrive now leaves

queue.popleft()                 # The second to arrive now leaves

queue                           # Remaining queue in order of arrival

zip()函数：

def f():
    '''
    issubclass
    '''
    a=[1,2,3]
    b=[4,5]
    print(list(zip(a,b)))

输出[(1,4),(2,5)]

字典

dict()构造函数直接从键-值对序列构建字典：

dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

字典的循环：
循环遍历字典时，可以使用该items()方法同时检索密钥和相应的值。

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

循环遍历序列时，可以使用该enumerate()函数同时检索位置索引和相应的值。

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

文件对象的读写

open()返回一个文件对象，最常见的用法带有两个参数：open(filename, mode)。参数1是含有文件名的字符串。参数2也是字符串，以几个字符说明该文件的使用方式。mode为’r’表示文件只读；w表示文件只进行写入（已存在的同名文件将被删掉）；'a’表示打开文件进行追加；写入到文件中的任何数据将自动添加到末尾。'r+‘表示打开文件进行读取和写入。mode参数是可选的；如果省略，则默认为’r’。

• 可以调用f.read(size) ，该方法读取若干数量的数据并以字符串（在文本模式中）或字节对象（在二进制模式中）形式返回它
• f.readline()从文件读取一行数据；字符串结尾会带有一个换行符 (\n)
• f.write(string) 将 字符串 的内容写入到该文件，返回写入的字符数。
• f.tell()返回一个整数，代表文件对象在文件中的当前的位置，在二进制模式中该数值表示自文件开头到指针处的字节数，在文本模式中则是不准确的
• f.seek(offset,from_what)要更改该文件对象的位置，可以使用f.seek(offset, from_what)。位置由参考点加上offset 计算得来；参考点的选择则来自于from_what参数。当from_what的值为0，1，2 时，分别使用文件开头、当前文件位置和文件结尾作为参考点。from_what 可以省略，默认值为 0，表示以文件的开始作为参考点
• 处理文件对象时使用with关键字是很好的做法。这样做的好处在于文件用完后会自动关闭，即使过程中发生异常也没关系。它还比编写一个等同的try-finally语句要短很多：

`with open('workfile', 'r') as f:
    read_data = f.read()
f.closed

json 存储数据

格式转为json
 >>> json.dumps([1, ‘simple’, ‘list’])
 ‘[1, “simple”, “list”]’json解码：
 x = json.load(f)

强制制作异常

raise 语句允许程序员强行引发一个指定的异常

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: HiThere

finally必须执行

>>> def divide(x, y):
...     try:
...         result = x / y
...     except ZeroDivisionError:
...         print("division by zero!")
...     else:
...         print("result is", result)
...     finally:
...         print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide

global和nonlocal的区别

第一，两者的功能不同。global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

第二，两者使用的范围不同。global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误（见第一）

继承

当然，一个语言如果没有支持继承特性不值得称作“类”

class DerivedClassName(BaseClassName):

多继承：

class DerivedClassName(Base1, Base2, Base3):

dir()函数

内置函数dir()用于找出模块定义的名称。它返回一个排序的字符串列表

调用函数

text.py

import sys
import numpy as np
from text2 import Text
t=Text()

text2.py class Text():
def text2_f():
print(‘123’)

输出前缀：f

格式化的字符串文字（也简称为f字符串）允许您通过在字符串前加上f或者F将表达式写为 字符串
例如：

import math
print(f’The value of pi is approximately {math.pi:.3f}.’)
The value of pi is approximately 3.142.

私有变量和方法

在python中定义私有变量只需要在变量名或函数名前加上 ”__“两个下划线，那么这个函数或变量就是私有的了。
在内部，python使用一种 name mangling 技术，将 __membername替换成 _classname__membername，也就是说，类的内部定义中,
所有以双下划线开始的名字都被"翻译"成前面加上单下划线和类名的形式。
例如：为了保证不能在class之外访问私有变量，Python会在类的内部自动的把我们定义的__spam私有变量的名字替换成为
_classname__spam(注意，classname前面是一个下划线，spam前是两个下划线)，因此，用户在外部访问__spam的时候就会
提示找不到相应的变量。 python中的私有变量和私有方法仍然是可以访问的；访问方法如下：
私有变量:实例._类名__变量名
私有方法:实例._类名__方法名()
例如：

class Text():
	def __init__(self):
		self.__data=['23']
		self.infor=['12']
	def add(self,items):
		self.__data.append(items)
	def show(self):
		print(self._data)
t=Text()
# print(t.__data)
print(t.__data)  #会报错
print(t._Text__data) #不会报错

其实，Python并没有真正的私有化支持，但可用下划线得到伪私有。 尽量避免定义以下划线开头的变量！
（1）_xxx "单下划线 " 开始的成员变量叫做保护变量，意思是只有类实例和子类实例能访问到这些变量，
需通过类提供的接口进行访问；不能用’from module import *'导入
（2）__xxx 类中的私有变量/方法名 （Python的函数也是对象，所以成员方法称为成员变量也行得通。）,
" 双下划线 " 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
（3） __ xxx __ 系统定义名字，前后均有一个“双下划线” 代表python里特殊方法专用的标识，如 init（）代表类的构造函数。

生成迭代器

for语句调用容器对象的iter()方法

>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
    next(it)
StopIteration

os 获取当前文件所在的位置

import os 
path=os.getcwd()
print(path)

输出：c://workspace

glob模块提供一个对目录中的文件进行通配符搜索的函数

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

字符串模板的匹配

一种运用正则表达式

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

另一种：使用replace

>>> 'tea for too'.replace('too', 'two')
'tea for two'

urllib 处理request

>>> from urllib.request import urlopen
>>> with urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl') as response:
...     for line in response:
...         line = line.decode('utf-8')  # Decoding the binary data to text.
...         if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...             print(line)

<BR>Nov. 25, 09:43:32 PM EST

smtplib 处理邮件发送

>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('[e-mail]', '[e-mail]',
... """To: [e-mail]
... From: [e-mail]
...
... Beware the Ides of March.
... """)
>>> server.quit()

datetime模块提供了处理日期和时间的简单和复杂的方法

>>> # dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'

>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

数据的压缩：zlib，gzip，bz2，lzma zipfile和tarfile。

#-*-coding=utf-8-*-
'''
压缩和解压函数
'''
#-*-coding=utf-8-*-
'''
压缩和解压函数
'''
import zlib
import zipfile

def zlib_demo():
	data=b'hello world hello world hello world  '
	print('start data：',len(data))
	compress_data=zlib.compress(data)
	print('compress data',len(compress_data))
	print('decompress darta',len(zlib.decompress(compress_data)))
	#文件对象
	# with open('inform.txt','wb') as file:
		# file.write(zlib.compress(data))
	with open('inform.txt','rb') as file:
		zlib.decompress(file.read())

def zipfile_demo():
	#创建压缩包
	with zipfile.ZipFile(r'file.zip','a') as file:
		#向压缩包中添加文件
		file.write('inform.txt')
		#测试压缩包
		error =file.testzip()
		if error:
			print('压缩文件错误',error)
			return
if __name__ == '__main__':
	zipfile_demo()

collections 模块提供了一个 deque()对象，像list但是拥有从左边更快的赋值速度和读取速度，但是从中间检索会更慢

例如：

>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print("Handling", d.popleft())
Handling task1

十进制浮点算术：例如Decimal(‘0.1’)，一定不要忘了括号内的引号

decimal模块提供了用于十进制浮点运算的Decimal数据类型。与内置的float二进制浮点的实现相比，该类特别有用
财务应用程序和其他用途，需要精确的十进制表示形式，
控制精度，
对符合法律或法规要求，舍入的控制
跟踪有效小数位
用户希望计算结果与手工计算相符的应用程序

>>> Decimal('1.00') % Decimal('.10')
Decimal('0.00')
>>> 1.00 % 0.10
0.09999999999999995

>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
False

用pip管理软件包

一种方式：通过制定的一个包的名称来安装最新版本的包
pip install novas
第二种方式：
通过给出包的名称后面==和版本号来安装一个软件包
pip install requets=2.70
通过运行pip install upgrade 来升级包到最新版本
pip uninstall 后面跟随一个或多个包的名称从虚拟环境中删除这些包