python初识(三)
目录:
- 字符编码
- 文件操做
- 循环结构拾遗
- 函数
- 总体介绍
- 函数的参数
- 函数的返回值
- 函数的调用
- 自定义函数
1、字符编码
一、了解字符编码的知识储备node
a. 文件编辑存取文件的原理（nodepad++,pycharm,word)python
启动进程---〉打开文件---〉读取内容到内存（断电会丢失）---〉保存（flush刷入硬盘）linux
b. python解释器执行原理。编程
python解释器启动---〉进程打开.py文件---〉读取文件到内存----〉执行app
ps. 二者区别，在于python解释器能够执行python2.7
二、什么是字符编码编辑器
a. 众所周知，计算机通电工做，且只是经过高低电平（二进制，高为1，低为2）工做的。ide
b. 这就意味着计算机制认识数字，而人类的语言通过翻译转换成数字，驱使计算机干活这件事为编程。因此人类的语言通过翻译转换成数字，转化中的语言与数字的对应关系，咱们称为字符编码。函数
字符 ----〉字符编码表（翻译过程）---〉数字编码
三、unicode和utf-8（字符编码）
uncicode：简单粗暴，全部字符最少2bytes，优势为字符--〉数字的转换速度快，缺点为占用空间大。（内存中使用）
uft-8:精准，可变字符长度，优势节省空间，缺点转换过程慢，由于须要计算当前字符的长度。（硬盘中使用）
四、字符编码的使用：
a. 读取和保存过程图
b.不管使用何种编辑器，要防止乱码，核心法则为，文件以什么编码保存，就应以什么编码方式打开。
五、python程序的执行过程。
a. python解释器启动---〉进程打开.py文件---〉读取文件到内存----〉执行
b. 执行步骤细节：
1 # 加载到内存，所占用的内存为unicode编码二进制 2 print('====>') 3 x = 'shuyang' #结果shuyang, 临时申请内存，unicode编码二进制，程序结束释放 4 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
1 python2.7 2 #coding:utf-8 3 s=u'林' #当程序执行时，'林'会被以unicode形式保存新的内存空间中 4 5 # s指向的是unicode，于是能够编码成任意格式，都不会报encode错误 6 # 由于系统默认字符集，输出显示为GBK，pycharm为UTF-8 7 s1=s.encode('utf-8') 8 s2=s.encode('gbk') 9 print s1 #控制台打印乱码，pycharm正常 10 print s2 #控制台正常，pycharm乱码 11 12 13 print repr(s) #u'\u6797' 14 print repr(s1) #'\xe6\x9e\x97' 编码一个汉字utf-8用3Bytes 15 print repr(s2) #'\xc1\xd6' 编码一个汉字gbk用2Bytes 16 17 print type(s) #<type 'unicode'> 18 print type(s1) #<type 'str'> 19 print type(s2) #<type 'str'> 20 '''
python3.0(str -->unicode, bytes--->bytes)
1 #coding:utf-8 2 s='林' #当程序执行时，无需加u，'林'也会被以unicode形式保存新的内存空间中, 3 4 #s能够直接encode成任意编码格式 5 s.encode('utf-8') 6 s.encode('gbk') 7 8 print(type(s)) #<class 'str'>
1 #coding:utf-8 2 s='林' #当程序执行时，无需加u，'林'也会被以unicode形式保存新的内存空间中, 3 4 #s能够直接encode成任意编码格式 5 s1=s.encode('utf-8') 6 s2=s.encode('gbk') 7 8 9 10 print(s) #林 11 print(s1) #b'\xe6\x9e\x97' 在python3中，是什么就打印什么 12 print(s2) #b'\xc1\xd6' 同上 13 14 print(type(s)) #<class 'str'> 15 print(type(s1)) #<class 'bytes'> 16 print(type(s2)) #<class 'bytes'>
2、文件操做
一、文件处理流程
a.打开文件---〉获取文件对象---〉关闭文件
b.read.txt内容
1 演员 - 薛之谦 2 词：薛之谦 3 曲：薛之谦 4 简单点说话的方式简单点 5 递进的情绪请省略 6 你又不是个演员 7 别设计那些情节 8 没意见我只想看看你怎么圆 9 你难过的太表面 像没天赋的演员 10 观众一眼能看见 11 该配合你演出的我演视而不见 12 在逼一个最爱你的人即兴表演 13 何时咱们开始收起了底线 14 顺应时代的改变看那些拙劣的表演 15 可你曾经那么爱我干吗演出细节 16 我该变成什么样子才能延缓厌倦 17 原来当爱放下防备后的这些那些 18 才是考验 19 没意见你想怎样我都随便 20 你演技也有限 21 又不用说感言 22 分开就平淡些 23 该配合你演出的我演视而不见 24 别逼一个最爱你的人即兴表演 25 何时咱们开始没有了底线 26 顺着别人的谎话被动就不显得可怜 27 可你曾经那么爱我干吗演出细节 28 我该变成什么样子才能配合出演 29 原来当爱放下防备后的这些那些 30 都有个期限 31 其实台下的观众就我一个 32 其实我也看出你有点不舍 33 场景也习惯咱们来回拉扯 34 还计较着什么 35 其实说分不开的也不见得 36 其实感情最怕的就是拖着 37 越演到重场戏越哭不出了 38 是否还值得 39 该配合你演出的我尽力在表演 40 像情感节目里的嘉宾任人挑选 41 若是还能看出我有爱你的那面 42 请剪掉那些情节让我看上去体面 43 可你曾经那么爱我干吗演出细节 44 不在乎的样子是我最后的表演 45 是由于爱你我才选择表演 这种成全
二、基本操做
f = open('<路径+文件名>','<模式>'...) # 默认为r模式只读(read)
first_line = f.read_line() # 读取第一行
print(first_line)
f.close() # 关闭文件
1 ''' 2 一、基本操做 3 ''' 4 f = open('read.txt', encoding='utf-8') # 默认为r模式只读(read) 5 first_line = f.readline() # 读取第一行 6 print(first_line) 7 f.close() # 关闭文件
三、文件打开模式
打开文件时，须要指定文件路径和以何等方式打开文件，打开后，便可获取该文件句柄，往后经过此文件对象对该文件操做。
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方式打开时，读取到的内容是字节类型，写入时也须要提供字节类型，不能指定编码
四、文件内置函数
1 ''' 2 二、文件的内置函数 3 ''' 4 # 按行读取 5 # f = open('read.txt', encoding='utf-8') 6 # a = f.readline() # 按行读取 7 # print(a) 8 # f.close() 9 10 # 按行所有读取为list 11 # f = open('read.txt', encoding='utf-8') 12 # a = f.readlines() # 按行所有读取为list 13 # print(a) 14 # f.close() # 关闭 15 16 # 默认所有读取，读取指定字符数据 17 # f = open('read.txt', encoding='utf-8') 18 # a = f.read() # 默认所有读取，读取指定字符数据 19 # print(a) 20 # f.close() # 关闭 21 22 # 返回一个长整型的"文件标签" 23 # f = open('read.txt', encoding='utf-8') 24 # a = f.fileno() # 返回一个长整型的"文件标签" 25 # print(a) 26 # f.close() 27 28 # 返回文件名 29 # f = open('read.txt', encoding='utf-8') 30 # a = f.name # 返回文件名 31 # print(a) 32 # f.close() 33 34 # 返回文件编码 35 # f = open('read.txt', encoding='utf-8') 36 # a = f.encoding # 返回文件编码 37 # print(a) 38 # f.close() 39 40 # 强制刷新写入硬盘，不建议频繁使用 41 # f = open('read.txt', encoding='utf-8') 42 # a = f.flush() # 强制刷新写入硬盘，不建议频繁使用 43 # print(a) 44 # f.close() 45 46 # 判断文件是不是赞成tty设备 47 # f = open('read.txt', encoding='utf-8') 48 # a = f.isatty() # 判断文件是不是赞成tty设备 49 # print(a) 50 # f.close() 51 52 # 判断文件是否可读 53 # f = open('read.txt', encoding='utf-8') 54 # a = f.readable() # 判断文件是否可读 55 # print(a) 56 # f.close() 57 58 # 指定文件中指针位置 59 # f = open('read.txt', encoding='utf-8') 60 # a = f.seek(0) # 指定文件中指针位置 0为文件开始，以字节为单位 61 # print(a) 62 # f.close() 63 64 # 指针是否可操做 65 # f = open('read.txt', encoding='utf-8') 66 # a = f.seekable() # 指针是否可操做 67 # print(a) 68 # f.close() 69 70 # 获取指针位置，以字节为单位 71 # f = open('read.txt', encoding='utf-8') 72 # a = f.tell() # 获取指针位置，以字节为单位 73 # print(a) 74 # f.close() 75 76 # 截断数据，仅保留指定以前数据，以字节为单位 77 # f = open('read.txt', encoding='utf-8') 78 # a = f.truncate(4) # 截断数据，仅保留指定以前数据，以字节为单位 79 # print(a) 80 # f.close() 81 82 # 判断文件是否可写 83 # f = open('read.txt','w', encoding='utf-8') 84 # a = f.writable() # 判断文件是否可写 85 # print(a) 86 # f.close() 87 88 # 清空文件后，写入内容 89 # f = open('read.txt','w', encoding='utf-8') 90 # f.write() # 清空文件后，写入内容 91 # f.close() 92 93 # 清空文件后，写入多个内容list，dict 94 # f = open('read.txt','w', encoding='utf-8') 95 # f.writelines(['a','b','c']) # 清空文件后，写入多个内容list，dict 96 # f.close()
ps. read(3)表明读取3个字符，其他的文件内光标移动都是以字节为单位如seek，tell，read，truncate
五、文件操做语法
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
六、上下文管理
1 ''' 2 二、文件的内置函数 3 ''' 4 # 按行读取 5 # f = open('read.txt', encoding='utf-8') 6 # a = f.readline() # 按行读取 7 # print(a) 8 # f.close() 9 10 # 按行所有读取为list 11 # f = open('read.txt', encoding='utf-8') 12 # a = f.readlines() # 按行所有读取为list 13 # print(a) 14 # f.close() # 关闭 15 16 # 默认所有读取，读取指定字符数据 17 # f = open('read.txt', encoding='utf-8') 18 # a = f.read() # 默认所有读取，读取指定字符数据 19 # print(a) 20 # f.close() # 关闭 21 22 # 返回一个长整型的"文件标签" 23 # f = open('read.txt', encoding='utf-8') 24 # a = f.fileno() # 返回一个长整型的"文件标签" 25 # print(a) 26 # f.close() 27 28 # 返回文件名 29 # f = open('read.txt', encoding='utf-8') 30 # a = f.name # 返回文件名 31 # print(a) 32 # f.close() 33 34 # 返回文件编码 35 # f = open('read.txt', encoding='utf-8') 36 # a = f.encoding # 返回文件编码 37 # print(a) 38 # f.close() 39 40 # 强制刷新写入硬盘，不建议频繁使用 41 # f = open('read.txt', encoding='utf-8') 42 # a = f.flush() # 强制刷新写入硬盘，不建议频繁使用 43 # print(a) 44 # f.close() 45 46 # 判断文件是不是赞成tty设备 47 # f = open('read.txt', encoding='utf-8') 48 # a = f.isatty() # 判断文件是不是赞成tty设备 49 # print(a) 50 # f.close() 51 52 # 判断文件是否可读 53 # f = open('read.txt', encoding='utf-8') 54 # a = f.readable() # 判断文件是否可读 55 # print(a) 56 # f.close() 57 58 # 指定文件中指针位置 59 # seek()的三种模式： 60 # （1）f.seek(p,0) 移动当文件第p个字节处，绝对位置 61 # （2）f.seek(p,1) 移动到相对于当前位置以后的p个字节 62 # （3）f.seek(p,2) 移动到相对文章尾以后的p个字节 63 # f = open('read.txt', encoding='utf-8') 64 # a = f.seek(0) # 指定文件中指针位置 0为文件开始，以字节为单位 65 # print(a) 66 # f.close() 67 68 # 指针是否可操做 69 # f = open('read.txt', encoding='utf-8') 70 # a = f.seekable() # 指针是否可操做 71 # print(a) 72 # f.close() 73 74 # 获取指针位置，以字节为单位 75 # f = open('read.txt', encoding='utf-8') 76 # a = f.tell() # 获取指针位置，以字节为单位 77 # print(a) 78 # f.close() 79 80 # 截断数据，仅保留指定以前数据，以字节为单位 81 # f = open('read.txt', encoding='utf-8') 82 # a = f.truncate(4) # 截断数据，仅保留指定以前数据，以字节为单位 83 # print(a) 84 # f.close() 85 86 # 判断文件是否可写 87 # f = open('read.txt','w', encoding='utf-8') 88 # a = f.writable() # 判断文件是否可写 89 # print(a) 90 # f.close() 91 92 # 清空文件后，写入内容 93 # f = open('read.txt','w', encoding='utf-8') 94 # f.write() # 清空文件后，写入内容 95 # f.close() 96 97 # 清空文件后，写入多个内容list，dict 98 # f = open('read.txt','w', encoding='utf-8') 99 # f.writelines(['a','b','c']) # 清空文件后，写入多个内容list，dict 100 # f.close()
七、文件的修改
1 ''' 2 四、 文件修改 3 ''' 4 import os 5 with open('read.txt', 'r', encoding='utf-8') as f, \ 6 open('write.txt', 'w', encoding='utf-8') as f2: 7 for i in f: 8 if i.startswith('什么'): 9 i = 'li,li,li' 10 f2.write(i) 11 12 # os.remove('read.txt') 13 # os.rename('write.txt', 'read.txt')
八、linux下tail实现原理
1 # tail -f access.log 2 import time 3 with open('access.log','r',encoding='utf-8') as f: 4 f.seek(0,2) 5 while True: 6 line=f.readline().strip() 7 if line: 8 print('新增一行日志',line) 9 time.sleep(0.5)
3、循环结构拾遗
循环体 ... else... 表示当循环不被break打断，就会执行else的代码
一、for...else...使用
1 # for循环 2 # for i in range(3): 3 # print(i) 4 # # continue 5 # if i == 1: 6 # break 7 # else: 8 # print('=============>') #当for循环不被break打断，就会执行else的代码 9 10 # 单行读取文件，写入到新文件 11 # with open('a.txt','r',encoding='utf-8') as read_f,\ 12 # open('aa.txt','w',encoding='utf-8') as write_f: 13 # 14 # for line in read_f: 15 # write_f.write(line) 16 # else: 17 # print('write successfull')
二、while...else...使用
1 # while循环 2 # i=0 3 # while i< 5: 4 # print(i) 5 # i+=1 6 # if i == 3: 7 # break 8 # else: 9 # print('------>')
4、函数
一、总体介绍
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中即使是过程也能够算做函数。
1 def test01(): 2 msg='hello The little green frog' 3 print msg 4 5 def test02(): 6 msg='hello WuDaLang' 7 print msg 8 return msg 9 10 11 t1=test01() 12 13 t2=test02() 14 15 16 print 'from test01 return is [%s]' %t1 17 print 'from test02 return is [%s]' %t2
b.为什么使用函数：函数是程序里没有没有缺点的应用，使用率很高
- 函数的特色（不使用函数会怎样？）
- 减小重复代码（无组织无结构，代码冗余）
- 是程序变得易维护（没法统一管理且维护成本高）
- 是程序变得易扩展（可读性差）
二、函数的分类：
按创建类型分：内置函数，自定义函数
a. 内置函数：系统预先设计好的函数，能够直接调用，如：sum(), max(),mix(),len()...
b. 自定义函数
1 #自定义函数 2 3 # # ****** 4 # # ****** 5 # # ****** 6 # # hello world 7 # # ****** 8 # # ****** 9 # # ****** 10 # 11 def print_star(): 12 print('#'*6) 13 14 def print_msg(): 15 print('hello world') 16 17 print_star() 18 print_star() 19 print_star() 20 print_msg() 21 print_star() 22 print_star() 23 print_star()
三、函数的参数
a. 从大的角度去看，函数的参数分两种：形参(变量名)，实参（值）
-
-
- 形参：形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。所以，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
- 实参：实参能够是常量、变量、表达式、函数等，不管实参是何种类型的量，在进行函数调用时，它们都必须有肯定的值，以便把这些值传送给形参。所以应预先用赋值，输入等办法使参数得到肯定值
- 示例：
-
1 #定义阶段：x,y为形参 2 # def foo(x,y): #x=1,y=2 3 # print(x) 4 # print(y) 5 6 #调用阶段：1，2位实参 7 # foo(1,2)
b.详细的区分函数的参数分为五种：位置参数，关键字参数，默认参数，可变长参数（*args，**kwargs）,命名关键字参数
-
-
- 位置参数:位置形参，必须被传值的参数。位置实参数：与形参一一对应。
-
1 #位置参数 2 def foo(x,y,z):#位置形参:必须被传值的参数 3 print(x,y,z) 4 5 # foo(1,2,3) 6 foo(1,2,3) #位置实参数：与形参一一对应
-
-
- 关键字参数：key=value
-
1 def foo(x,y,z): 2 print(x,y,z) 3 4 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) #错误
-
-
- 默认参数
-
1 def register(name,age,sex='male'): #形参：默认参数 2 print(name,age,sex) 3 4 register('asb',age=40) 5 register('a1sb',39) 6 register('a2sb',30) 7 register('a3sb',29) 8 9 register('钢蛋',20,'female') 10 register('钢蛋',sex='female',age=19)
ps.默认参数须要注意的问题：
1)默认参数必须跟在非默认参数后。
1 def register(sex='male',name,age): #在定义阶段就会报错 2 print(name,age,sex)
2)默认参数在定义阶段就已经赋值了，并且只在定义阶段赋值一次(了解)。
1 #（了解）二：默认参数在定义阶段就已经赋值了，并且只在定义阶段赋值一次 2 # a=100000000 3 # def foo(x,y=a): 4 # print(x,y) 5 # a=0 6 # foo(1) 7 # 结果: x = 1 y = 100000000
3)默认参数的值一般定义成不可变类型
-
-
- 可变长参数:*args, **kwargs
- *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args
- **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs
- 示例：
-
1 # *args示例 2 # def foo(x,y,*args): # *会把溢出的按位置定义的实参都接收，以元组的形式赋值给args 3 # print(x,y) 4 # print(args) 5 # 6 # foo(1,2,3,4,5) 7 8 # *args示例2 9 # def add(*args): 10 # res=0 11 # for i in args: 12 # res+=i 13 # return res 14 # print(add(1,2,3,4)) 15 # print(add(1,2)) 16 17 18 # **kwargs示例 19 # def foo(x, y, **kwargs): # **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs 20 # print(x, y) 21 # print(kwargs) 22 # foo(1,2,a=1,name='egon',age=18) 23 24 # **kwargs示例2 25 # def foo(name,age,**kwargs): 26 # print(name,age) 27 # if 'sex' in kwargs: 28 # print(kwargs['sex']) 29 # if 'height' in kwargs: 30 # print(kwargs['height']) 31 # 32 # foo('egon',18,sex='male',height='185') 33 # foo('egon',18,sex='male')
-
-
- 命名关键字参数(了解)：*后定义的参数为命名关键字参数，这类参数，必须被传值，并且必须以关键字实参的形式去传值
-
1 # def foo(name,age,*,sex='male',height): 2 # print(name,age) 3 # print(sex) 4 # print(height) 5 # #*后定义的参数为命名关键字参数，这类参数，必须被传值，并且必须以关键字实参的形式去传值 6 # foo('egon',17,height='185')
c.综合实例应用：
-
-
- 首先为参数的应用顺序：def foo(name,age=10,*args,sex='male',height,**kwargs): 位置参数，默认参数，*可变长参数，命名参数，关键参数，**可变长参数
-
ps.不建议都用，会形成相互串扰
1 # def foo(name,age=10,*args,sex='male',height,**kwargs): 2 # print(name) 3 # print(age) 4 # print(args) 5 # print(sex) 6 # print(height) 7 # print(kwargs) 8 # 9 # foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
-
-
- 其余实例：（*args， **kwargs）
-
1 # *args参数将位置参数转化过程：转化为元祖 2 # def foo(*args): 3 # print(args) 4 5 # foo(1,2,3,4) # 1,2,3,4 <=====>*(1,2,3,4) 6 7 #*['A','B','C','D'],=====>'A','B','C','D' 8 # foo(*['A','B','C','D']) #foo('A','B','C','D') 9 # foo(['A','B','C','D']) # 10 11 # list实参加*回传 12 # def foo(x,y,z): 13 # print(x,y,z) 14 # 15 # # foo(*[1,2,3]) #foo(1,2,3) 16 # foo(*[1,2]) #foo(1,2) 17 18 # **kwargs将关键参数转换为字典 19 # def foo(**kwargs): 20 # print(kwargs) 21 # 22 # #x=1,y=2 <====>**{'y': 2, 'x': 1} 23 # # foo(x=1,y=2) 24 # 25 # foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1) 26 27 # dict实参加**回传 28 # def foo(x,y,z): 29 # print(x,y,z) 30 # 31 # # foo(**{'z':3,'x':1,'y':2}) #foo(x=1,z=3,y=2) 32 # foo(**{'z':3,'x':1}) #foo(x=1,z=3) 33 34 # 综合1基础 35 # def foo(x,y,z): 36 # print('from foo',x,y,z) 37 # 38 # def wrapper(*args,**kwargs): 39 # print(args) 40 # print(kwargs) 41 # 42 # 43 # wrapper(1,2,3,a=1,b=2) 44 45 46 # 综合函数调用 47 # def foo(x,y,z): 48 # print('from foo',x,y,z) 49 # def wrapper(*args,**kwargs): 50 # print(args) #args=(1,2,3) 51 # print(kwargs) #kwargs={'a':1,'b':2} 52 # foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1) 53 # # wrapper(1,2,3,a=1,b=2) 54 # wrapper(1,z=2,y=3) 55 56 57 # 综合函数调用 -- 错误 58 # def foo(x,y,z): 59 # print('from foo',x,y,z) 60 # def wrapper(*args,**kwargs): 61 # # print(args) #args=(1,) 62 # # print(kwargs) #kwargs={'y':3,'z':2} 63 # foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3) 64 # # wrapper(1,2,3,a=1,b=2) 65 # wrapper(1,z=2,y=3)
四、函数的返回值
a.返回值为None
1 # def foo(): 2 # print('from foo') 3 # return None 4 # res=foo() 5 # print(res) 6 7 ''' 8 如下三种状况返回值都为None： 9 没有return 10 return 什么都不写 11 return None 12 '''
b.return 一个值 函数调用返回的结果就是这个值
1 # def foo(): 2 # print('from foo') 3 # x=1 4 # return x 5 # res=foo() 6 # print(res) 7 8 #return 一个值 函数调用返回的结果就是这个值
c.return 多个值
1 # def foo(): 2 # print('from foo') 3 # x=1 4 # return 1,[2,3],(4,5),{} 5 # res=foo() 6 # print(res) #打印结果：(1,[2,3],(4,5),{}) 7 # a,b,c,d=foo() 8 # print(d) 9 10 #return 值1,值2，值3,... 返回结果:(值1,值2，值3,...) 11 12 # t=(1,2,3) 13 # a,_,_=t # 不想要后面的值_ 14 # print(a) 15 16 # t=(1,2,3,4,5,6,7,8,9) 17 # a,*_,c=t # 不想要中心的值*_ 18 # print(a) 19 # print(c)
五、函数的调用
按照有参和无参能够将函数调用分两种:
a. 定义时无参，调用时也无需传入参数。b. 定义时有参，调用时也必须有参数。
1 def foo(): 2 print('from foo') 3 4 def bar(name): 5 print('bar===>',name) 6 7 # 按照有参和无参能够将函数调用分两种 8 foo() #定义时无参，调用时也无需传入参数 9 bar('egon') #定义时有参，调用时也必须有参数
按照函数的调用形式和出现的位置，分三种：
a. 调用函数的语句形式。b. 调用函数的表达式形式。c. 把函数调用当中另一个函数的参数。
1 #按照函数的调用形式和出现的位置，分三种 2 3 foo() #调用函数的语句形式 4 5 def my_max(x,y): 6 res=x if x >y else y 7 return res 8 9 # res=my_max(1,2)*10000000 #调用函数的表达式形式 10 # print(res) 11 12 13 res=my_max(my_max(10,20),30) #把函数调用当中另一个函数的参数 14 print(res)
六、自定义函数
a.先定义后使用，若是没有定义而直接使用，就至关于引用了一个不存在的变量名
1 #错误 2 # foo() 3 # def foo(): 4 # print('from foo') 5 # print(foo)
b.定义函数的三种形式：无参数函数，有参函数，空函数
1 #一：无参数函数：若是函数的功能仅仅只是执行一些操做而已，就定义成无参函数，无参函数一般都有返回值 2 # def print_star(): 3 # print('#'*6) 4 5 #二：定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数一般都有返回值 6 # def my_max(x,y): 7 # res=x if x >y else y 8 # return res 9 10 #三：空函数：占位，定程序结构 11 12 # def auth(): 13 # """认证功能""" 14 # pass 15 # auth() 16 # def insert(): 17 # """插入功能""" 18 # pass 19 # def select(): 20 # """查询功能""" 21 # pass 22 # def delete(): 23 # """删除功能""" 24 # pass 25 # def update(): 26 # """更新功能""" 27 # pass
ps.三元表达式
1 # x=10 2 # y=2 3 # if x > y: 4 # print(x) 5 # else: 6 # print(y) 7 # 8 # res=x if x > y else y 9 # print(res)
函数待续......
相关文章
- 1. python-初识python
- 2. Python - 初识Python
- 3. Python——初识Python
- 4. Python-初识python
- 5. python初识（二） python初识（一）
- 6. JavaScript初识(三)
- 7. JAVA初识（三）
- 8. ansible初识三
- 9. 初识三层
- 10. 三层--初识
- 更多相关文章...
- • SQLite - Python - SQLite教程
- • Docker 安装 Python - Docker教程
- • 适用于PHP初学者的学习线路和建议
- • RxJava操作符（三）Filtering
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. python-初识python
- 2. Python - 初识Python
- 3. Python——初识Python
- 4. Python-初识python
- 5. python初识（二） python初识（一）
- 6. JavaScript初识(三)
- 7. JAVA初识（三）
- 8. ansible初识三
- 9. 初识三层
- 10. 三层--初识