参数必须按顺序传递，个数目前要对应
编写程序，给函数两个数，返回两个数的和
def myprint(num1,num2)
将结构返回给函数的调用者
return num1 + num2
执行完return语句，该函数结束，return后面的代码不执行
比如 print（"****"） 在return后面，所以不会执行
传递参数：值传递，引用传递
值传递：传递的不可变类型
string、tuple、numbe是不可变的
def func1(num):
num = 10
temp = 20
func1(temp)
print(temp) 打印结果是20
引用传递:传递的可变类型
list、dict、set是可变的
def func2(lis):
lis[0] = 100
li = [1,2,3,4,5]
func2(li)
print(li) 打印结果是[100,2,3,4,5]
关键字参数
概念：允许函数调用时的顺序与定义时的不一致
def myPrint(str,age):
print(str,age)
使用关键字参数
myPrint(str = suya,age = 11) 等号前面的就是关键字参数
使用默认参数，最好将默认参数放到最后
def myPrint(str,age = 18):
print(str,age)
myPrint("kaige") 打印出来是kaige 18
加了星号（*）的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组
de func(name, *arr)：
print（name）
print（type（arr））
for x in arr:
print(x)
func("sunck","good","nice","handsom"
)
需求：编写一个函数，给函数一个字符串和年龄，在函数内部打印出来
def myPrint(str,age):
print(str,age)
实参（实际参数：调用函数时给函数传递的数据，本质是值）
myPrint("suya,11")
形参：定义函数时小括号中的变量，本质是变量
递归：在函数内部，可以调用其他函数，如果一个函数在内部调用自己本身，这个就是递归。
def recursion(n,total = 0):
if n == 0:
return total
else:
return recursion(n-1)+n
匿名函数：lambda表达式
格式：lambda参数1，参数2：结果表达式
l_sum = lambda x, y : x + y
l_sum(10,30) # 返回40
等价于：
def l_sum(x):
return x+y
l_sum(10,30) # 返回40
装饰器：
不带参数的装饰器：
def show_time(f):
def inner():
start = time.time()
f()
end = time.time()
print('spend %s'%(end - start))
return inner
@show_time #foo=show_time(f)
def foo():
print('foo...')
time.sleep(1)
foo()
def bar():
print('bar...')
time.sleep(2)
bar()
带参数的装饰器：
import time
def time_logger(flag=0):
def show_time(func):
def wrapper(*args, *kwargs):
start_time = time.time()
func(args, **kwargs)
end_time = time.time()
print('spend %s' % (end_time - start_time))
if flag:
print('将这个操作的时间记录到日志中')
return wrapper
return show_time
@time_logger(flag=1)
def add(*args, **kwargs):
time.sleep(1)
sum = 0
for i in args:
sum += i
print(sum)
add = time_logger(flag = 1)(add)
add(1, 2, 5)
文件的复制：
import shutil #导包
复制文件
sourceFile = r"d:\video\day01.mp4"
targetFile = r"e:\video\day01.mp4"
shutil.copyfile(sourceFile,targetFile) #shutil.copyfile(参数1, 参数2) # 参数1:源文件路径; 参数2: 目标文件路径
复制目录
source_file = r"d:\codes"
target_file = r"e:\codes"
shutil.copytree(source_file, target_file)
random模块：
import random #导入模块
随机整数
random.randint(0,99)
21
随机选取0到100间的偶数
random.randrange(0, 101, 2)
42
随机浮点数
random.random()
0.85415370477785668
random.uniform(1, 10)
5.4221167969800881
随机字符
random.choice('abcdefg&#%^*f')
'd'
多个字符中选取特定数量的字符
random.sample('abcdefghij', 3)
['a', 'd', 'b']
多个字符中选取特定数量的字符组成新字符串
''.join( random.sample(['a','b','c','d','e','f','g','h','i','j'], 3) )
'fih'
随机选取字符串
random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )
'lemon'
洗牌
items = [1, 2, 3, 4, 5, 6]
random.shuffle(items)
items
自定义异常：
class MyException(Exception):
def init(self,message):
Exception.init(self)
self.message=message
a=input("please input a num:")
if a<10:
try:
raise MyException("my excepition is raised ")
except MyException,e:
print e.message
面向对象：
类：类（Class）是面向对象实现信息封装的基础。类是一种用户定义类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
实例：实例指类实例化的结果，也称为对象。是我们在程序中所要使用的一个个具体的操作实体。
实例化：实例化是指在面向对象的编程中，用类创建对象的过程。
私有属性：一般定义为仅能在内部使用的属性，在python中指以__开头命名的方法及属性。python私有属性事实上可以在外部使用。
类属性：我们定义出来的属于类的属性。该属性影响该类的所有实例。
实例属性：实例属性属于实例，仅影响当前实例。需要注意的是在访问的时候遵循向下开放原则，修改遵循向上闭合原则即著名的开闭原则。
继承：类（class）可以通过继承获得父类的所有属性及方法。类的默认继承类为object，因此object是所有类的祖类。
-
重写：在子类中可以声明父类中的同名类实现自己的业务逻辑，这种方法叫做类的重写。
语法格式：
class 类名([父类1，...]):
'''
类说明文档
'''
[类属性1名 = 值]
[类属性2名 = 值[def 方法1名(参数1[，......]):
方法代码段
[@装饰器]
def 方法2名(参数1[，...]):
方法代码段]