Python入门笔记0二ca88会员登录中心,python函数回想

ca88会员登录中心 4
ca88会员登录中心

当def函数参数默认值为对象时,例如列表[],字典{}

二、函数

1.参数的介绍

(1)可变和不可变参数

(2)必选参数

(3)默认参数

(4)可变参数

(5)关键字参数


 

 

1.1.可变和不可变参数

示例1:猜测一下,会输出什么??? 

2.1、重新认识函数

不可变类型:

类似 c++ 的值传递,如
整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在
fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。

def ddd(a,b=[]):
    b.append(a)
    return b

print(ddd(1))
print(ddd(2,['a','b','c']))
print(ddd(3))

ca88会员登录中心 1

可变类型:

类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la
真正的传过去,修改后fun外部的la也会受影响

引用。


 

     Python
中所谓的使用函数,就是把你要处理的对象放到一个名字后面的括号里。简单来说,函数就是这么使用的,往里面塞东西就可以得到处理结果。

1.2.必选参数

必选参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

例如:

def f(a,b):

print(‘jjjjjj’)

return a+b

print(f(1,2))

输出结果为:

jjjjjj


[1] 
[‘a’,’b’,’c’,’2′] [3]   ?????你是否认为是这样? 输出一下看看

 

1.3.默认参数

调用函数时,缺省参数的值如果没有传入,则被认为是默认值

例如:

def f(a,b=100):

    print(‘********************’)

    return a+b

print(f(1))

print(f(1,b=20))

print(f(1,3))

print(‘############################$$$#############################’)

def f(a=100,b=200):

    print(‘****************’)

    return a+b

print(f(1,2))

print(3,2)

print(f())

print(f(3))

输出结果为:

********************

101

********************

21

********************

4

############################$$$#############################

****************

3

3 2

****************

300

****************

203


输出结果:

– Python 的 内建函数(Built-in Functions)

1.4.可变参数-元组

在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。参数组装成一个tutple

def calc(*numbers):

    sum = 0

   for n in numbers:

        sum = sum + n * n

        return sum

例如:

def f(*num):

    print(num)

f(1,2,3,4,5)

f(100,101)

f(111)

f([1,2,3,4],None,True,{‘a’:4})

f()

print(‘***********************************$$$**********************************’)

def f1(*args):

    print(sum(args))

num1=1

num2=2

num3=3

f1(num1,num2,num3)

ls=[1,2,3,4,5]

f1(ls[0],ls[1],ls[2],ls[3],ls[4])

ls=[i for i in range(10)]

f(*ls)

f(ls)

输出结果为:

(1, 2, 3, 4, 5)

(100, 101)

(111,)

([1, 2, 3, 4], None, True, {‘a’: 4})

()

***********************************$$$**********************************

6

15

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],)

45


D:\Python27\python.exe D:/untitled1/temp5.py
[1]
['a', 'b', 'c', 2]
[1, 3]

 

1.5.可变参数-字典

变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):

    print(‘name:’, name, ‘age:’, age, ‘other:’, kw)

例如:

def f(**kvs):

    print(kvs)

f(a=1,b=’abc’,c=[1,2,3])

infos={‘a’:1,’b’:2}

f(**infos)

输出结果为:

{‘c’: [1, 2, 3], ‘a’: 1, ‘b’: ‘abc’}

{‘a’: 1, ‘b’: 2}

=


 

以 Python 3.60 版本为例,一共存在 68 个这样的函数,它们被统称为
内建函数(Built-in Functions)。

1.6.关键字参数

对于关键字参数,函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些,就需要在函数内部通过kw检查。

注意:如果要限制关键字参数的名字,就可以用命名关键字参数。

def person(name, age, *, city, job):

    print(name, age, city, job)

例如:

def f(a,b):

    print(‘a=%s,b=%s’%(a,b))

f(b=1,a=2)

输出结果为:

a=2,b=1


看到以上结果有什么想法,为什么呢???[1,
3]而不是[3],那么修改一下代码,输出b变量的内存地址看一下。我想,可以找到我要的答案

之所以被称为内建函数,并不是因为还有“外建函数”这个概念,“内建”的意思是在
Python 3.60 版本安装完成后,你无须创建就可以直接使用这些函数,即
表示这些函数是“自带”的而已。

1.7.参数组合

在Python中定义函数,可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数,这5种参数都可以组合使用。但是请注意,参数定义的顺序必须是:

必选参数、默认参数、可变参数。

例如:

def f(a,b=1,*c,**d):

print(a)

print(b)

print(c)

print(d)

f(1,2,3,4,5,6,dd=100,bb=30)

输出结果为:

1

2

(3, 4, 5, 6)

{‘bb’: 30, ‘dd’: 100}

=


def ddd(a,b=[]):
    b.append(a)
    print(id(b)) #查看内存地址
    return b

print(ddd(1))
print(ddd(2,['a','b','c']))
print(ddd(3))

 

1.8.变量作用域介绍

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:

输出结果:

Python 3.60 的 68个 内建函数(Built-in Functions):

全局变量

D:\Python27\python.exe D:/untitled1/temp5.py
170580872
[1]
171586568
['a', 'b', 'c', 2]
170580872
[1, 3]
    Built-in Functions    
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()  
delattr() hash() memoryview() set()  

局部变量

从输出中,可以看出,除了,第二个print,其它两个内存是一们的。那么考虑一下为什么第二个为被改变。结果显而易见,因为第二个print改变了,b对象,重新创建了一个对象。

 

(1).局部变量

局部变量,就是在函数内部定义的变量

不同的函数,可以定义相同的名字的局部变量,但是各用个的不会产生影响

局部变量的作用,为了临时保存数据需要在函数中定义变量来进行存储,这就是它的作用

 

 

(2).全局变量

如果一个变量,既能在一个函数中使用,也能在其他的函数中使用,这样的变量就是全局变量

如果要再函数中修改全局变量,使用global声明。

例如:

a=100

print(a)

print(‘******************************’)

def f():

    a=200

f()

print(a)

以上代码中,定义了一个全局变量,a=100,定义了一个没有返回值和参数的函数f,在函数中定义了一个局部变量a=200。

输出结果为:

100

******************************

100

第二个结果,虽然有局部变量但是没有被调用,调用的还是全局变量a=100.

def f(a):

    print(‘num=%s’%num)

num=111

f(100)

print(num)

输出结果为:

num=111

111

以上代码,定义了一个全局变量,而没有局部变量,num=111,当f=100时,会输出num=111.

def f(num):

    print(‘num=%s’%num)

num=111

f(100)

print(num)

输出结果为:

num=100

111

以上代码,定义了一个局部变量个一个全局变量,就近原则有限使用局部变量。

def f(num):

    num+=1

    print(‘num=%s’%num)

num=111

f(100)

print(num)

输出结果为:

num=101

111

以上代码,有一个局部变量,和一个全局变量,在函数运行时,调用了局部变量,此时的全局变量并没有变。

num=111

def f():

    global num

    print(‘num1=%s’%num)

    num+=1

    print(‘num2=%s’%num)

f()

print(‘num3=%s’%num)

输出结果为:

num1=111

num2=112

num3=112

以上代码中,global num
定义了一个全局变量,此时为全局变量。此时的全局变量已经改变。

=


那么如果不想出现,每次调用,默认值对象不变的问题,可以这样改一下:

2.2、创建函数

1.9.全局和局部变量重名

如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量

在函数外边定义的变量叫做全局变量

全局变量能够在所以的函数中进行访问

如果在函数中修改全局变量,那么就需要使用global进行声明

如果全局变量的名字和局部变量的名字相同,那么使用的是局部变量的,

小技巧强龙不压地头蛇

=


def ddd(a,b=None):
    if type(b).__name__!='list':
        b = []

    b.append(a)
    print(id(b)) #查看内存地址
    return b

print(ddd(1))
print(ddd(2,['a','b','c']))
print(ddd(3))

 

1.10.递归函数

如果一个函数在内部不调用其它的函数,而是自己本身的话,这个函数就是递归函数。

满足递归的条件:

有循环的内容

有跳出的条件

递归默认是有递归深度要求的。

=


初始值设置为None,通过类型判断来,进行内处理

– Python 创建函数的格式如下:

1.11.匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句,如下:

lambda [arg1 [,arg2,…..argn]]:expression

注意:

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

 

 

小结:

ca88会员登录中心 2

      
1.python定义def的时候,如果参数做为对象,那么,如果没有改变这个对象的前提下,那么即使,多次调用该函数也,不会创建新的对象。

 

         
那么就会出现多次调用函数,有可能都进行了处理。

 

  2.如果,没有特殊需求,函数参数,尽量不采用对象,如果一有需要,对象进行内处理。传默认值None

★ 重 点:

 

  ① def(即 define
,定义)的含义是创建函数,也就是定义一个函数。

  ② 闭合括号后面的 冒号( )必不可少。

  ③ 函数「缩进」后面的语句被称作
语句块(block),缩进是为了表明语句和逻辑的从属关系,是 Python
最显著的特征之一。(大部分语言会用大括号 { } 来表明这样从属关系)

  ④ return 即返回结果。在 Python 中 return 是可选的,如果没有 return
即函数的返回值为 ‘None’。 

 

☆ 注意:

  ① def 和 return 是 关键字(keyword),Python
就是靠识别这些特定的关键字来明白用户的意图,实现更为复杂的编程。

  ② 在 Python 中 return 是可选的(optional),这意味着你在创建函数时不写 return 也可以顺利地定义一个函数并调用,只不过
返回值 是 ‘None’ 罢了。

  ③ 我们把 使用函数 这种行为叫做“调用”(call)。即 调用函数 。

 

ca88会员登录中心 3

 

# 例子,温度的单位有 摄氏度 和 华氏度
,已知 摄氏度 与 华氏度 的转化公式为:F = 9/5*C+32 。

# 现在我们创建一个能实现 摄氏度 转化为
华氏度 的函数,并调用该函数实现转化:

 

def temp_converter(c):

return str(9/5*c+32) + ‘?F’

 

c_in = input(‘请输入摄氏温度:’)

c_in = int(c_in)

f = temp_converter(c_in)

print(‘华氏温度为:’ + f)

 

 

2.3、传递参数与参数类型

 

– 位置参数 与 关键词参数

 

    根据不同传递参数的方式,可以分为:位置参数 (positional argument)
与 关键词参数 (keyword argument)。

 

    在 调用函数 时,根据 该函数被创建时
各参数所在的位置顺序,分别把参数的值按顺序填到对应的位置,这样种传入参数的方式被称作「位置参数 (positional
argument)」。

 

    在 调用函数
时,在每个参数名称后面赋予一个我们想要传入的值。这种以名称作为一一对应的参数传入方式被称作「关键词参数 (keyword
argument)」。

 

ca88会员登录中心 4

 

# 例子,我们已知 梯形面积的计算公式为:S =
(a+b)*h/2

# 创建一个函数,计算梯形面积:

 

def tra_area(a,b,h):

return 1/2 * (a + b) * h

 

print(tra_area(h=3,b=2,a=1)) #
-成功,输出:4.5

print(tra_area(h=3,b=2,1)) #
-失败!原因:「位置参数」不能在「关键词参数」之后出现!

print(tra_area(a=1,b=2,3)) # 
-失败!原因:「位置参数」不能在「关键词参数」之后出现!

print(tra_area(1,2,h=3)) #
-成功,输出:4.5

print(tra_area(1,2,b=3)) #
-失败!原因:同一个参数不能被重复赋值!

 

☆ 注意:

    ①「关键词参数」可以不考虑位置顺序。

    ②「位置参数」不能在「关键词参数」之后出现!

    ③ 同一个参数不能被重复赋值!

 

#
我们现在给一组变量赋值,然后再调用函数,大家来看结果会有什么变化:

 

a = 1

b = 2

h = 3

print(tra_area(h,b,a)) # 输出:2.5

print(tra_area(h = h,b = b,a = a)) #
输出:4.5

 

☆ 注意:

    在 创建函数 时 设定的参数是「形参」,在 调用函数 时
填入的参数是「实参」,大家要搞清楚这两个概念。

 

– 默 认 参 数

 

    默认参数 就是
函数中某个有默认值的参数。调用函数时就算不给予填入参数,该函数仍然能照常运行。

 

  参数的默认值可以被更改,即 默认参数可以被重新赋值。

 

   
给一个参数设定默认值(创建默认参数)非常简单,我们只需要在定义参数的时候给参数赋值即可。如下:

 

def tra_area(a,b,h=3):

return 1/2 * (a + b) * h

 

print(tra_area(1,2)) # 输出:4.5

print(tra_area(1,2,6)) # 给默认参数重新赋值 6,输出:9.0

print(tra_area(1,2,h=6)) # 给默认参数重新赋值 6,输出:9.0

 

 ☆ print()函数的默认参数
sep(用于设定多个打印结果之间的分隔符号)的默认值为‘
’空格,但是我们可以将其重新设定为‘/n’ 即 换行
。也就是说将每个打印结果以换行符号进行分割。如下:

 

print(‘  *’,’ ***’,’*****’,’  |’,sep=’\n’)

”””””””””””””””””’

以上代码输出:

  *

 ***

*****

  |

”””””””””””””””””’

 

 

2.4、设计自己的函数

 

  * 如果你现在困惑 函数 和 方法
到底是什么关系的话,为了顺利地往后进行,我可以告诉你 方法 就是 函数
的一种,只不过在不同的位置而已,使用原理和函数非常相似。

 

# 创建 file_create()
函数,作用:创建文件(尤其是.py文件)

# 该函数共有4个参数:

# namn -文件名

# content -文件内容

# extension -文件扩展名,即 后缀

# path -文件坐在的目录路径

def file_create(name,content,extension=’py’,path=’E:/PY_Test/New/’):

full_path = path + name + ‘.’ + extension

file = open(full_path,’w’)

file.write(content)

file.close()

print(‘文件 ‘ + name + ‘.’ + extension + ‘ 已被创建在 ‘ + path + ‘
中。’)

 

file_create(‘test’,’# hello world’) #
调用函数

 

 

# 创建 word_filter()
函数,作用:单词过滤器

# 该函数共有3个参数:

# content -内容

# target_word -要被过滤的单词

# new_word – 替换的单词

# 执行成功 返回
被过滤后的内容(str类型)。

def word_filter(content,target_word=’lame’,new_word=’Awesome’):

return content.replace(target_word,new_word)

 

new_content = word_filter(‘Python is lame! is very lame!! is very very
lame!!!’) # 调用函数

print(new_content)

# 输出:Python is Awesome! is very
Awesome!! is very very Awesome!!!

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图