2021-02-25

函数：
带个return

没有return的话
print func()输出结果就是 None

1.函数基本概念

2.参数 <=> 抽象

3.参数 分为 可选参数 必须的参数

‘’’

‘’’
更复杂的需求

1 + 2 = 3

1 + 2 + 3

1 + 2+ …+ 1000

def add(*num):
	d = 0
	for i in num:
		d += i
	return d

print add(1,2,3,4,5)



def add(*num):

	d = 0
	for i in num:
		d += i
	return d

print add(1,2,3,4,5)


print add(1,2,3)


print add(2,4,6,8,1,2,3,4,12312,12314,123,123,123)

var1
var2
var3

var1 = None

1.可选参数 是有默认值的

2.必须参数 是没有默认值的

默认值和没有默认值的区别在于 “=”

函数的健壮性

1.你永远知道你的方法会返回什么（异常处理，条件判断）
2.返回你想要的结果

‘’’

def add(num1 ,num2):

if isinstance(num1,int) and isinstance(num2, int):
	return num1+num2
else:
	return '参数里有不是数字的类型'

print add(‘a’,(1,2,3))

print add(1,2)

assert add(1,2) == 3

assert add(2,4) == 3

怎么去学习使用函数

（1）别管那么多复杂的，先直接把功能实现了。
（2）抽象成函数：命名规范，伪代码,参数默认值。
（3）将函数变得更健壮，让它可以跑很多地方
				1.假设你写的函数是要交给你的基友用 -》 功能完整
				2.假设你写的函数是要交给你的学弟用 -》 异常处理完善
(4) 测试
				1.assert
				2.对函数的返回进行一个值和类型的测试。
				3.单元测试

def func1(a,b,c,d,e):
“”“
@a:

”“”
pass

下划线命名线 get_doc
驼峰命名法 getDocFromUrl

为什么要用默认值：
1.更省事
2.更可配置

x表示和a中的每一个元素进行迭代
b=[5]

进阶 面向对象第一节 初识class

1.如何去定义一个最基本的class
2.class最基本的子元素
3.class传参
4.__init__方法
5.class和函数的区别

“”"

class test(object):


	"""

	get被称之为test对象的方法

	"""

	def __init__(self,var1):
		self.var1 = var1


	def get(self,a=None):
		return self.var1

	pass



def get(a):
	return a

“”"
t是类test的一个实例
“”"
t = test(‘test str heiheihei’)
print t.get()

“”"
如何去使用对象内置的方法
1.实例化这个class （test） t = test()
2.使用 class.method()的方式去调用 class 的内置方法

注意：
1.当定义一个class的内置方法method时，method的参数的第一个永远是self。
“”"

# new_var = 4

# print t.get(new_var)

# print get(new_var)

多线程

进程 pid 唯一标示符
使用kill 杀死进程

主线程 创造一个进程的时候，会创造一个线程，这个线程被称为主线程
一个进程里只有一个主线程

python里的多线程，不是真正意义上的多线程。

全局锁

在任意的指定时间里，有且只有一个线程在运行

a b c
‘’’

import threading
import time



def test(p):
	time.sleep(0.001)
	print p

ts = []

for i in xrange(0,15):
	th = threading.Thread(target=test,args=[i])
	th.start()
	ts.append(th)


#for i in ts:
#	 i.join()

print "hoho,end!!!!!"

如果没有join，那么print“hello，end”的值就会随机出现在线程，有了join，print的值只会出现在最后

1.全局锁（GIL）是一个很重要的概念。

在任意一个指定的时间，有且只有一个线程在运行 -》 python是线程安全的

线程安全 歧义

2.多线程 复杂度高，不建议使用。（它用在哪里？）

一个程序的复杂度，大部分情况下，只和代码行数有关。
简单 ！= 简陋

数据库连接池

3.多线程还是有点爽的，比如？

4.io操作用到多线程？必须要lock，acquire release
互斥锁

加锁 acquire
释放锁 release
加锁 一定 释放
死锁

5.rlock 可重入锁

‘’’

# import threading

# num = 0
# def t():
# 	global num
# 	num += 1
# 	print num

# for i in xrange(0,10):
# 	d = threading.Thread(target=t)
# 	d.start()

import time

def a():
print 'a begin'
time.sleep(2)
print 'a end'

def b():
print 'b begin'
time.sleep(2)
print 'b end'

# b_time = time.time()
# a()
# b()
# print time.time() - b_time #代码完成时间


# import threading


# b_time = time.time()

# _a = threading.Thread(target=a)
# _b = threading.Thread(target=b)
# _a.start()
# _b.start()

# _a.join()
# _b.join()

# print time.time() - b_time #代码完成时间


import threading

mlock = threading.RLock()

num = 0
def a():
global num

mlock.acquire() #加锁
num += 1 #你要执行的代码
mlock.release() #释放锁

print num

for i in xrange(0,10):
d = threading.Thread(target=a)
d.start()

协程入门

yield 生成器

1.包含yield的函数，则是一个可迭代对象。

利用next方法，取每一次的yield
send

2.生产者，消费者行为
3.无需立刻执行，需要时才执行
4.斐波拉切数列的例子

1,1,2,3,5,8,13,


for i in fun(13):
print i

1
1
2
3
5
8


'''

# a = [1,2,3,4]
# for i in a:
# 	print i


def test():

x = yield '第一步，他会直接返回哟'
print '哈哈，第一次哟%s'%x
x = yield '%s,它每次请求，不管是send，还是next，都会往下一直跑到下一个yield，并且，把yield后面的值返回回来哟'%x
print '哈哈，第二次哟%s'%x
x = yield 

t = test()
print t.next()
#print t.next()
print t.send('嘻嘻嘻，这样才是赋值给第一个x哟！')
print t.send('z这是给第二个赋值哟')

#print t.send('嘻嘻，试下')
#print t.send(5)

# print type(range(0,5))
# print type(xrange(0,5))


#for i in xrange(0,5):
#	print i

素数：

‘’’
正则表达式，是字符串检索引擎，最早起源于unix。

1.unix下的正则 awk grep egrep
2.正则的几个基本概念

[0-9] \d 全部数字

\w 单词类字符 a-z A-Z 0-9 _
\W 非单词类字符

{2} {n} 前面的表达式匹配n次
{0,2} {m,n} 前面的表达式匹配m到n次

• 前面的表达式，出现1到无限次 最少，出现1次
  ? 前面的表达式，出现0到1次 最多，出现1次

• 前面的表达式，出现0到无限次 出现不出现，都没关系

3.python里的正则模块 re
4.一些基本操作

4.1 一次取配 match:“hello lilei” r’(\w+) (\w+)’
4.2 切割 split
4.3 查找全部 findall
4.4 finditer 迭代器什么的最有爱了