python初识(三)

目录:

• 字符编码
• 文件操作
• 循环结构拾遗
• 函数
  • 整体介绍
  • 函数的参数
  • 函数的返回值
  • 函数的调用
  • 自定义函数

一、字符编码

1、了解字符编码的知识储备

　　a. 文件编辑存取文件的原理（nodepad++,pycharm,word)

　　　 启动进程---〉打开文件---〉读取内容到内存（断电会丢失）---〉保存（flush刷入硬盘）

　　b. python解释器执行原理。

　　　python解释器启动---〉进程打开.py文件---〉读取文件到内存----〉执行

　　ps. 两者区别，在于python解释器可以执行

2、什么是字符编码

　　a. 众所周知，计算机通电工作，且只是通过高低电平（二进制，高为1，低为2）工作的。

b. 这就意味着计算机制认识数字，而人类的语言经过翻译转换成数字，驱使计算机干活这件事为编程。所以人类的语言经过翻译转换成数字，转化中的语言与数字的对应关系，我们称为字符编码。

字符 ----〉字符编码表（翻译过程）---〉数字

3、unicode和utf-8（字符编码）

　　uncicode：简单粗暴，所有字符最少2bytes，优点为字符--〉数字的转换速度快，缺点为占用空间大。（内存中使用）

uft-8:精准，可变字符长度，优点节省空间，缺点转换过程慢，因为需要计算当前字符的长度。（硬盘中使用）

4、字符编码的使用：

a. 读取和保存过程图

b.无论使用何种编辑器，要防止乱码，核心法则为，文件以什么编码保存，就应以什么编码方式打开。

5、python程序的执行过程。

　　a. python解释器启动---〉进程打开.py文件---〉读取文件到内存----〉执行

　　b. 执行步骤细节：

 # 加载到内存，所占用的内存为unicode编码二进制
 print('====>')
 x = 'shuyang' #结果shuyang, 临时申请内存，unicode编码二进制，程序结束释放
 y = x.encode('utf-8') #结果b'shuyang'，临时申请内存，unicode编码二进制，程序结束释放

c.python2与python3的区别：

• • 在python2中，str就是编码后的结果bytes，str=bytes,所以在python2中，unicode字符编码的结果是str/bytes
  • 在python2解释器执行到产生字符串的代码时（例如s=u'林'），会申请新的内存地址，然后将'林'以unicode的格式存放到新的内存空间中，所以s只能encode，不能decode
  • python3中的字符串与python2中的u'字符串'，都是unicode，所以无论如何打印都不会乱码
  • 示例：

python2.7

 python2.7
 #coding:utf-8
 s=u'林' #当程序执行时，'林'会被以unicode形式保存新的内存空间中

 # s指向的是unicode，因而可以编码成任意格式，都不会报encode错误
 # 因为系统默认字符集，输出显示为GBK，pycharm为UTF-8
 s1=s.encode('utf-8')
 s2=s.encode('gbk')
 print s1 #控制台打印乱码，pycharm正常
 print s2 #控制台正常，pycharm乱码

 print repr(s) #u'\u6797'
 print repr(s1) #'\xe6\x9e\x97' 编码一个汉字utf-8用3Bytes
 print repr(s2) #'\xc1\xd6' 编码一个汉字gbk用2Bytes

 print type(s) #<type 'unicode'>
 print type(s1) #<type 'str'>
 print type(s2) #<type 'str'>
 '''

　　python3.0(str -->unicode, bytes--->bytes)

 #coding:utf-8
 s='林' #当程序执行时，无需加u，'林'也会被以unicode形式保存新的内存空间中,

 #s可以直接encode成任意编码格式
 s.encode('utf-8')
 s.encode('gbk')

 print(type(s)) #<class 'str'>

 #coding:utf-8
 s='林' #当程序执行时，无需加u，'林'也会被以unicode形式保存新的内存空间中,

 #s可以直接encode成任意编码格式
 s1=s.encode('utf-8')
 s2=s.encode('gbk')

 print(s) #林
 print(s1) #b'\xe6\x9e\x97' 在python3中，是什么就打印什么
 print(s2) #b'\xc1\xd6' 同上

 print(type(s)) #<class 'str'>
 print(type(s1)) #<class 'bytes'>
 print(type(s2)) #<class 'bytes'>

二、文件操作

1、文件处理流程

a.打开文件---〉获取文件对象---〉关闭文件

b.read.txt内容

 演员 - 薛之谦
 词：薛之谦
 曲：薛之谦
 简单点说话的方式简单点
 递进的情绪请省略
 你又不是个演员
 别设计那些情节
 没意见我只想看看你怎么圆
 你难过的太表面 像没天赋的演员
 观众一眼能看见
 该配合你演出的我演视而不见
 在逼一个最爱你的人即兴表演
 什么时候我们开始收起了底线
 顺应时代的改变看那些拙劣的表演
 可你曾经那么爱我干嘛演出细节
 我该变成什么样子才能延缓厌倦
 原来当爱放下防备后的这些那些
 才是考验
 没意见你想怎样我都随便
 你演技也有限
 又不用说感言
 分开就平淡些
 该配合你演出的我演视而不见
 别逼一个最爱你的人即兴表演
 什么时候我们开始没有了底线
 顺着别人的谎言被动就不显得可怜
 可你曾经那么爱我干嘛演出细节
 我该变成什么样子才能配合出演
 原来当爱放下防备后的这些那些
 都有个期限
 其实台下的观众就我一个
 其实我也看出你有点不舍
 场景也习惯我们来回拉扯
 还计较着什么
 其实说分不开的也不见得
 其实感情最怕的就是拖着
 越演到重场戏越哭不出了
 是否还值得
 该配合你演出的我尽力在表演
 像情感节目里的嘉宾任人挑选
 如果还能看出我有爱你的那面
 请剪掉那些情节让我看上去体面
 可你曾经那么爱我干嘛演出细节
 不在意的样子是我最后的表演
 是因为爱你我才选择表演 这种成全

2、基本操作

　　f = open('<路径+文件名>','<模式>'...) # 默认为r模式只读(read)

　　first_line = f.read_line() # 读取第一行

　　print(first_line)

　　f.close() # 关闭文件

 '''
 1、基本操作
 '''
 f = open('read.txt', encoding='utf-8') # 默认为r模式只读(read)
 first_line = f.readline() # 读取第一行
 print(first_line)
 f.close() # 关闭文件

3、文件打开模式

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件对象对该文件操作。

a. 打开文件的模式有：

• • • r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
    • w，只写模式【不可读；不存在则创建；存在则清空内容】
    • x， 只写模式【不可读；不存在则创建，存在则报错】
    • a， 追加模式【可读；   不存在则创建；存在则只再末尾追加内容】

b. "+" 表示可以同时读写某个文件

• • • r+， 读写【可读，可写】
    • w+，写读【可写，可读】
    • x+ ，写读【可读，可写】
    • a+， 写读【可读，可写】

c. "b"表示以字节的方式操作，需要decode解码，encode编码，二进制可编辑图片，音频等等

• • • rb  或 r+b
    • wb 或 w+b
    • xb 或 w+b
    • ab 或 a+b

ps.以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

4、文件内置函数

 '''
 2、文件的内置函数
 '''
 # 按行读取
 # f = open('read.txt', encoding='utf-8')
 # a = f.readline()  # 按行读取
 # print(a)
 # f.close()

 # 按行全部读取为list
 # f = open('read.txt', encoding='utf-8')
 # a = f.readlines()  # 按行全部读取为list
 # print(a)
 # f.close()  # 关闭

 # 默认全部读取，读取指定字符数据
 # f = open('read.txt', encoding='utf-8')
 # a = f.read()  # 默认全部读取，读取指定字符数据
 # print(a)
 # f.close()  # 关闭

 # 返回一个长整型的"文件标签"
 # f = open('read.txt', encoding='utf-8')
 # a = f.fileno()  # 返回一个长整型的"文件标签"
 # print(a)
 # f.close()

 # 返回文件名
 # f = open('read.txt', encoding='utf-8')
 # a = f.name  # 返回文件名
 # print(a)
 # f.close()

 # 返回文件编码
 # f = open('read.txt', encoding='utf-8')
 # a = f.encoding  # 返回文件编码
 # print(a)
 # f.close()

 # 强制刷新写入硬盘，不建议频繁使用
 # f = open('read.txt', encoding='utf-8')
 # a = f.flush()  # 强制刷新写入硬盘，不建议频繁使用
 # print(a)
 # f.close()

 # 判断文件是否是同意tty设备
 # f = open('read.txt', encoding='utf-8')
 # a = f.isatty()  # 判断文件是否是同意tty设备
 # print(a)
 # f.close()

 # 判断文件是否可读
 # f = open('read.txt', encoding='utf-8')
 # a = f.readable()  # 判断文件是否可读
 # print(a)
 # f.close()

 # 指定文件中指针位置
 # f = open('read.txt', encoding='utf-8')
 # a = f.seek(0)  # 指定文件中指针位置 0为文件开始，以字节为单位
 # print(a)
 # f.close()

 # 指针是否可操作
 # f = open('read.txt', encoding='utf-8')
 # a = f.seekable()  # 指针是否可操作
 # print(a)
 # f.close()

 # 获取指针位置，以字节为单位
 # f = open('read.txt', encoding='utf-8')
 # a = f.tell()  # 获取指针位置，以字节为单位
 # print(a)
 # f.close()

 # 截断数据，仅保留指定之前数据，以字节为单位
 # f = open('read.txt', encoding='utf-8')
 # a = f.truncate(4)  # 截断数据，仅保留指定之前数据，以字节为单位
 # print(a)
 # f.close()

 # 判断文件是否可写
 # f = open('read.txt','w', encoding='utf-8')
 # a = f.writable()  # 判断文件是否可写
 # print(a)
 # f.close()

 # 清空文件后，写入内容
 # f = open('read.txt','w', encoding='utf-8')
 # f.write()  # 清空文件后，写入内容
 # f.close()

 # 清空文件后，写入多个内容list，dict
 # f = open('read.txt','w', encoding='utf-8')
 # f.writelines(['a','b','c'])  # 清空文件后，写入多个内容list，dict
 # f.close()

　　ps. read(3)代表读取3个字符，其余的文件内光标移动都是以字节为单位如seek，tell，read，truncate

5、文件操作语法

　　a.open()语法

open(file[, mode[, buffering[, encoding[, errors[, newline[, closefd=True]]]]]])
open函数有很多的参数，常用的是file，mode和encoding
file：文件位置，需要加引号
mode：文件打开模式
buffering：的可取值有0，1，>1三个，0代表buffer关闭（只适用于二进制模式），1代表line buffer（只适用于文本模式），>1表示初始化的buffer大小；
encoding：表示的是返回的数据采用何种编码，一般采用utf8或者gbk；
errors：的取值一般有strict，ignore，当取strict的时候，字符编码出现问题的时候，会报错，当取ignore的时候，编码出现问题，程序会忽略而过，继续执行下面的程序。
newline：可以取的值有None, \n, \r, ”, ‘\r\n'，用于区分换行符，但是这个参数只对文本模式有效；
closefd：的取值，是与传入的文件参数有关，默认情况下为True，传入的file参数为文件的文件名，取值为False的时候，file只能是文件描述符，什么是文件描述符，就是一个非负整数，在Unix内核的系统中，打开一个文件，便会返回一个文件描述符。

b.python2中file() 与open() 的区别

两者都能够打开文件，对文件进行操作，也具有相似的用法和参数，但是，这两种文件打开方式有本质的区别，file为文件类，用file()来打开文件，相当于这是在构造文件类，而用open()打开文件，是用python的内建函数来操作，建议使用open

6、上下文管理　

 '''
 2、文件的内置函数
 '''
 # 按行读取
 # f = open('read.txt', encoding='utf-8')
 # a = f.readline()  # 按行读取
 # print(a)
 # f.close()

 # 按行全部读取为list
 # f = open('read.txt', encoding='utf-8')
 # a = f.readlines()  # 按行全部读取为list
 # print(a)
 # f.close()  # 关闭

 # 默认全部读取，读取指定字符数据
 # f = open('read.txt', encoding='utf-8')
 # a = f.read()  # 默认全部读取，读取指定字符数据
 # print(a)
 # f.close()  # 关闭

 # 返回一个长整型的"文件标签"
 # f = open('read.txt', encoding='utf-8')
 # a = f.fileno()  # 返回一个长整型的"文件标签"
 # print(a)
 # f.close()

 # 返回文件名
 # f = open('read.txt', encoding='utf-8')
 # a = f.name  # 返回文件名
 # print(a)
 # f.close()

 # 返回文件编码
 # f = open('read.txt', encoding='utf-8')
 # a = f.encoding  # 返回文件编码
 # print(a)
 # f.close()

 # 强制刷新写入硬盘，不建议频繁使用
 # f = open('read.txt', encoding='utf-8')
 # a = f.flush()  # 强制刷新写入硬盘，不建议频繁使用
 # print(a)
 # f.close()

 # 判断文件是否是同意tty设备
 # f = open('read.txt', encoding='utf-8')
 # a = f.isatty()  # 判断文件是否是同意tty设备
 # print(a)
 # f.close()

 # 判断文件是否可读
 # f = open('read.txt', encoding='utf-8')
 # a = f.readable()  # 判断文件是否可读
 # print(a)
 # f.close()

 # 指定文件中指针位置
 # seek()的三种模式：
 # （1）f.seek(p,0)  移动当文件第p个字节处，绝对位置
 # （2）f.seek(p,1)  移动到相对于当前位置之后的p个字节
 # （3）f.seek(p,2)  移动到相对文章尾之后的p个字节
 # f = open('read.txt', encoding='utf-8')
 # a = f.seek(0)  # 指定文件中指针位置 0为文件开始，以字节为单位
 # print(a)
 # f.close()

 # 指针是否可操作
 # f = open('read.txt', encoding='utf-8')
 # a = f.seekable()  # 指针是否可操作
 # print(a)
 # f.close()

 # 获取指针位置，以字节为单位
 # f = open('read.txt', encoding='utf-8')
 # a = f.tell()  # 获取指针位置，以字节为单位
 # print(a)
 # f.close()

 # 截断数据，仅保留指定之前数据，以字节为单位
 # f = open('read.txt', encoding='utf-8')
 # a = f.truncate(4)  # 截断数据，仅保留指定之前数据，以字节为单位
 # print(a)
 # f.close()

 # 判断文件是否可写
 # f = open('read.txt','w', encoding='utf-8')
 # a = f.writable()  # 判断文件是否可写
 # print(a)
 # f.close()

 # 清空文件后，写入内容
 # f = open('read.txt','w', encoding='utf-8')
 # f.write()  # 清空文件后，写入内容
 # f.close()

 # 清空文件后，写入多个内容list，dict
 # f = open('read.txt','w', encoding='utf-8')
 # f.writelines(['a','b','c'])  # 清空文件后，写入多个内容list，dict
 # f.close()

7、文件的修改

 '''
 4、 文件修改
 '''
 import os
 with open('read.txt', 'r', encoding='utf-8') as f, \
     open('write.txt', 'w', encoding='utf-8') as f2:
     for i in f:
         if i.startswith('什么'):
             i = 'li,li,li'
         f2.write(i)

 # os.remove('read.txt')
 # os.rename('write.txt', 'read.txt')

　　8、linux下tail实现原理

 # tail -f access.log
 import time
 with open('access.log','r',encoding='utf-8') as f:
     f.seek(0,2)
     while True:
         line=f.readline().strip()
         if line:
             print('新增一行日志',line)
         time.sleep(0.5)

三、循环结构拾遗

　　循环体 ... else... 表示当循环不被break打断，就会执行else的代码

1、for...else...使用

 # for循环
 # for i in range(3):
 #     print(i)
 #     # continue
 #     if i == 1:
 #         break
 # else:
 #     print('=============>') #当for循环不被break打断，就会执行else的代码

 # 单行读取文件，写入到新文件
 # with open('a.txt','r',encoding='utf-8') as read_f,\
 #         open('aa.txt','w',encoding='utf-8') as write_f:
 #
 #     for line in read_f:
 #         write_f.write(line)
 #     else:
 #         print('write successfull')

2、while...else...使用

 # while循环
 # i=0
 # while i< 5:
 #     print(i)
 #     i+=1
 #     if i == 3:
 #         break
 # else:
 #     print('------>')

四、函数

1、整体介绍

a.数学定义的函数与python中的函数：

初中数学函数定义：一般的，在一个变化过程中，如果有两个变量x和y，并且对于x的每一个确定的值，y都有唯一确定的值与其对应，那么我们就把x称为自变量，把y称为因变量，y是x的函数。自变量x的取值范围叫做这个函数的定义域。例如y=2*x

python中函数定义：函数是逻辑结构化和过程化的一种编程方法。把一段程序代码，使用一种方式命名，以方便通过名字的方式调用。格式如下：

def 〈函数名〉（参数1，参数2，...）：

　　函数体

　　<return 值>

〈函数名〉（参数1，参数2，...） # 调用模式

ps.当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，所以在python中即便是过程也可以算作函数。

 def test01():
     msg='hello The little green frog'
     print msg

 def test02():
     msg='hello WuDaLang'
     print msg
     return msg

 t1=test01()

 t2=test02()

 print 'from test01 return is [%s]' %t1
 print 'from test02 return is [%s]' %t2

b.为何使用函数：函数是程序里没有没有缺点的应用，使用率很高

• 函数的特点（不使用函数会怎样？）
  • 减少重复代码（无组织无结构，代码冗余）
  • 是程序变得易维护（无法统一管理且维护成本高）
  • 是程序变得易扩展（可读性差）

2、函数的分类：

　　按建立类型分：内置函数，自定义函数

　　a. 内置函数：系统预先设计好的函数，可以直接调用，如：sum(), max(),mix(),len()...

　　b. 自定义函数

 #自定义函数

 # # ******
 # # ******
 # # ******
 # # hello world
 # # ******
 # # ******
 # # ******
 #
 def print_star():
     print('#'*6)

 def print_msg():
     print('hello world')

 print_star()
 print_star()
 print_star()
 print_msg()
 print_star()
 print_star()
 print_star()

3、函数的参数

　　a. 从大的角度去看，函数的参数分两种：形参(变量名)，实参（值）

• • • 形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
    • 实参：实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
    • 示例：

 #定义阶段：x,y为形参
 # def foo(x,y): #x=1,y=2
 #     print(x)
 #     print(y)

 #调用阶段：1，2位实参
 # foo(1,2) 

b.详细的区分函数的参数分为五种：位置参数，关键字参数，默认参数，可变长参数（*args，**kwargs）,命名关键字参数

• • • 位置参数:位置形参，必须被传值的参数。位置实参数：与形参一一对应。

 #位置参数
 def foo(x,y,z):#位置形参:必须被传值的参数
     print(x,y,z)

 # foo(1,2,3)
 foo(1,2,3) #位置实参数：与形参一一对应

• • • 关键字参数：key=value

 def foo(x,y,z):
     print(x,y,z)

 foo(z=3,x=1,y=2)

　　　　　　　　 ps.关键字参数需要注意的问题：

　　　　　　　　　　1)关键字实参必须在位置实参后面。如：foo(1,z=3,y=2) #正确

　　　　　　　　　　2)不能重复对一个形参数传值。如：foo(x=1,2,z=3) #错误，foo(1,x=1,2,z=3) #错误

• • • 默认参数

 def register(name,age,sex='male'): #形参：默认参数
     print(name,age,sex)

 register('asb',age=40)
 register('a1sb',39)
 register('a2sb',30)
 register('a3sb',29)

 register('钢蛋',20,'female')
 register('钢蛋',sex='female',age=19)

ps.默认参数需要注意的问题：

1)默认参数必须跟在非默认参数后。

 def register(sex='male',name,age): #在定义阶段就会报错
      print(name,age,sex)

2)默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次(了解)。

 #（了解）二：默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次
 # a=100000000
 # def foo(x,y=a):
 #     print(x,y)
 # a=0
 # foo(1)
 # 结果: x = 1 y = 100000000

3)默认参数的值通常定义成不可变类型

• • • 可变长参数:*args, **kwargs
    1. *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
    2. **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
    3. 示例：

 # *args示例
 # def foo(x,y,*args): # *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
 #     print(x,y)
 #     print(args)
 #
 # foo(1,2,3,4,5)

 # *args示例2
 # def add(*args):
 #     res=0
 #     for i in args:
 #         res+=i
 #     return res
 # print(add(1,2,3,4))
 # print(add(1,2))

 # **kwargs示例
 # def foo(x, y, **kwargs):  # **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
 #     print(x, y)
 #     print(kwargs)
 # foo(1,2,a=1,name='egon',age=18)

 # **kwargs示例2
 # def foo(name,age,**kwargs):
 #     print(name,age)
 #     if 'sex' in kwargs:
 #         print(kwargs['sex'])
 #     if 'height' in kwargs:
 #         print(kwargs['height'])
 #
 # foo('egon',18,sex='male',height='185')
 # foo('egon',18,sex='male')

• • • 命名关键字参数(了解)：*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值

 # def foo(name,age,*,sex='male',height):
 #     print(name,age)
 #     print(sex)
 #     print(height)
 # #*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值
 # foo('egon',17,height='185')

c.综合实例应用：

• • • 首先为参数的应用顺序：def foo(name,age=10,*args,sex='male',height,**kwargs): 位置参数，默认参数，*可变长参数，命名参数，关键参数，**可变长参数

ps.不建议都用，会造成相互串扰

 # def foo(name,age=10,*args,sex='male',height,**kwargs):
 #     print(name)
 #     print(age)
 #     print(args)
 #     print(sex)
 #     print(height)
 #     print(kwargs)
 #
 # foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)

• • • 其他实例：（*args， **kwargs）

 # *args参数将位置参数转化过程：转化为元祖
 # def foo(*args):
 #     print(args)

 # foo(1,2,3,4) # 1,2,3,4 <=====>*(1,2,3,4)

 #*['A','B','C','D'],=====>'A','B','C','D'
 # foo(*['A','B','C','D']) #foo('A','B','C','D')
 # foo(['A','B','C','D']) #

 # list实参加*回传
 # def foo(x,y,z):
 #     print(x,y,z)
 #
 # # foo(*[1,2,3]) #foo(1,2,3)
 # foo(*[1,2]) #foo(1,2)

 # **kwargs将关键参数转换为字典
 # def foo(**kwargs):
 #     print(kwargs)
 #
 # #x=1,y=2  <====>**{'y': 2, 'x': 1}
 # # foo(x=1,y=2)
 #
 # foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1)

 # dict实参加**回传
 # def foo(x,y,z):
 #     print(x,y,z)
 #
 # # foo(**{'z':3,'x':1,'y':2}) #foo(x=1,z=3,y=2)
 # foo(**{'z':3,'x':1}) #foo(x=1,z=3)

 # 综合1基础
 # def foo(x,y,z):
 #     print('from foo',x,y,z)
 #
 # def wrapper(*args,**kwargs):
 #     print(args)
 #     print(kwargs)
 #
 #
 # wrapper(1,2,3,a=1,b=2)

 # 综合函数调用
 # def foo(x,y,z):
 #     print('from foo',x,y,z)
 # def wrapper(*args,**kwargs):
 #     print(args) #args=(1,2,3)
 #     print(kwargs) #kwargs={'a':1,'b':2}
 #     foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)
 # # wrapper(1,2,3,a=1,b=2)
 # wrapper(1,z=2,y=3)

 # 综合函数调用 -- 错误
 # def foo(x,y,z):
 #     print('from foo',x,y,z)
 # def wrapper(*args,**kwargs):
 #     # print(args) #args=(1,)
 #     # print(kwargs) #kwargs={'y':3,'z':2}
 #     foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3)
 # # wrapper(1,2,3,a=1,b=2)
 # wrapper(1,z=2,y=3)

4、函数的返回值

　　a.返回值为None

 # def foo():
 #     print('from foo')
 #     return None
 # res=foo()
 # print(res)

 '''
 以下三种情况返回值都为None：
 没有return
 return 什么都不写
 return None
 '''

　　　　b.return 一个值 函数调用返回的结果就是这个值

 # def foo():
 #     print('from foo')
 #     x=1
 #     return x
 # res=foo()
 # print(res)

 #return 一个值  函数调用返回的结果就是这个值

c.return 多个值

 # def foo():
 #     print('from foo')
 #     x=1
 #     return 1,[2,3],(4,5),{}
 # res=foo()
 # print(res) #打印结果：(1,[2,3],(4,5),{})
 # a,b,c,d=foo()
 # print(d)

 #return 值1,值2，值3,...   返回结果:(值1,值2，值3,...)

 # t=(1,2,3)
 # a,_,_=t # 不想要后面的值_
 # print(a)

 # t=(1,2,3,4,5,6,7,8,9)
 # a,*_,c=t  # 不想要中心的值*_
 # print(a)
 # print(c)

5、函数的调用

　　按照有参和无参可以将函数调用分两种:

　　a. 定义时无参，调用时也无需传入参数。b. 定义时有参，调用时也必须有参数。

 def foo():
     print('from foo')

 def bar(name):
     print('bar===>',name)

 # 按照有参和无参可以将函数调用分两种
 foo() #定义时无参，调用时也无需传入参数
 bar('egon') #定义时有参，调用时也必须有参数

　　按照函数的调用形式和出现的位置，分三种：

　　a. 调用函数的语句形式。b. 调用函数的表达式形式。c. 把函数调用当中另外一个函数的参数。

 #按照函数的调用形式和出现的位置，分三种

 foo() #调用函数的语句形式

 def my_max(x,y):
     res=x if x >y else y
     return res

 # res=my_max(1,2)*10000000 #调用函数的表达式形式
 # print(res)

 res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数
 print(res)

6、自定义函数

a.先定义后使用，如果没有定义而直接使用，就相当于引用了一个不存在的变量名

 #错误
 # foo()
 # def foo():
 #     print('from foo')
 # print(foo)

b.定义函数的三种形式：无参数函数，有参函数，空函数

 #一：无参数函数：如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常都有返回值
 # def print_star():
 #     print('#'*6)

 #二：定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值
 # def my_max(x,y):
 #     res=x if x >y else y
 #     return res

 #三：空函数：占位，定程序结构

 # def auth():
 #     """认证功能"""
 #     pass
 # auth()
 # def insert():
 #     """插入功能"""
 #     pass
 # def select():
 #     """查询功能"""
 #     pass
 # def delete():
 #     """删除功能"""
 #     pass
 # def update():
 #     """更新功能"""
 #     pass

ps.三元表达式

 # x=10
 # y=2
 # if x > y:
 #     print(x)
 # else:
 #     print(y)
 #
 # res=x if x > y else y
 # print(res)

函数待续......