【Python】函数

函数

几乎所有的编程语言都有函数的概念，函数其实就是一段可重用的代码。

但是不同的语言有自己独特的风格。

我们看一个简单的python函数代码：

def hello():
	print("hello")

hello()

#输出 hello

定义方法和其它语言都是类似的，python中我们使用 def 来定义一个函数。

Java中，方法必须在一个类中定义方法，如果向下面这样定义一个函数，就会报错

如果调用执行这个函数，则要在 main() 方法中调用函数。

而Python中，直接在文件中调用即可

参数

Python是一门强类型语言

定义python函数的形参时，并不需要指定参数的类型，直接写上参数名即可。

def hello(name):
	print("Hello" + name)
    
hello("Jack")

传递任意数量的实参

def hello(*name):
	print(name)

hello("Jack", "Tom", "Anny")

#('Jack', 'Tom', 'Anny')

形参名*name 让Python创建一个名为name的空元组，并将收到的所有值都封装到这个元组中。

导入模块

模块就是扩展名为 .py 的文件

1. 导入一个模块

   import 模块名
   

   导入模块后我们就可以使用这个模块中的方法了

2. 导入特定的函数

   from 模块名 import 函数名
   

3. 使用as给函数指定别名

   from 模块名 import 函数名 as 函数别名
   

4. 使用as给模块指定别名

   from 模块名 as 模块别名
   

5. 导入模块中的所有函数

   from 模块名 import *
   

类

类就相当于一个模板，可以通过这个模板创建相应的对象。

方法

类中的函数称为 方法，但是和方法又和函数有区别

1、函数要手动传self，方法不用传self。

2、如果是一个函数，用类名去调用，如果是一个方法，用对象去调用。

__new__()

__new__()负责进行对象的创建

只有继承于object的新式类才能有__new__方法，

__new__方法在创建类实例对象时由Python解释器自动调用，一般不用自己定义，

Python默认调用该类的直接父类的__new__方法来构造该类的实例，

如果该类的父类也没有重写__new__，那么将一直按此规矩追溯至object的__new__方法，因为object是所有新式类的基类，若需要自定义__new__方法，一般用法如下：

class Person(object):
    def __new__(cls):
        return  object.__new__(cls)

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供；

__new__必须要有返回值，返回实例化出来的实例，可以return父类new出来的实例，或直接是object的new出来的实例。

object.new(cls)执行完返回的结果为Person类的实例对象，如下：

class Person(object):
    
    def __init__(self):
        print("__init__")
        self.name="张三"
        
    def __new__(cls):
        print('__new__')
        ob = object.__new__(cls)#ob为Person实例对象
        print(ob)
        return ob
    
p1 = Person()
print(p1.name)

p1 = Person()做了如下工作：

• 调用Person的 __new__()方法
• __new__()方法通过 object.new(cls)创建了Person实例对象并返回
• 调用Person实例对象的 __init__()方法

参考：https://blog.csdn.net/weixin_41557802/article/details/84190218

__init__()

Python中 __init__() 方法就是对象的 构造方法，在对象初始化时进行一系列的构建操作。

__init__() 方法必须接受至少一个参数 self。

self 是指向该对象本身的一个引用，通过在类的内部使用self变量，类中的方法可以访问自己的成员变量。

class Dog():
	def __init__(self, name):
		self.name = name
		
	def sit(self):
		print(self.name.title() + "is now sitting~")

self.name 就是 访问该对象的name属性；

• __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

• __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

• __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

__str__()

class Cat:

    def __init__(self, new_name, new_age):
        """在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
        # self.name = "汤姆"
        # self.age = 20
        self.name = new_name
        self.age = new_age  # 它是一个对象中的属性,在对象中存储,即只要这个对象还存在,那么这个变量就可以使用

    def __str__(self):

        return "名字是:%s , 年龄是:%d" % (self.name, self.age)


tom = Cat("汤姆", 30)
print(tom)

输出：

• 在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
• 当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
• __str__方法需要返回一个字符串，当做这个对象的描写

内置函数

Python 内置了很多有用的函数

• 数学运算(7)
• 类型转换(24)
• 序列操作(8)
• 对象操作(7)
• 反射操作(8)
• 变量操作(2)
• 交互操作(2)
• 文件操作(1)
• 编译执行(4)
• 装饰器(3)

数学运算

abs 求绝对值：

abs()

divmod 返回两个数值的商和于数

divmod(5,2)

min 返回可迭代对象中的元素最小值或者所有参数最小值

min(1,2,3)   #1
min('1234')  #'1'
min('min')   #'i'
min(-1,-2)   #-2
min(-1,-2,key=abs) # -1, 传入了abs函数，参数都会进行求绝对值都再取较小者

max 返回可迭代对象中的元素最小值或者所有参数最小值

max(1,2,3)   #3
max('1234')  #'4'
max('max')   #'x'
max(-1,-2)   #-1
max(-1,-2,key=abs) # -2, 传入了abs函数，参数都会进行求绝对值都再取较大者

pow 返回两个数值的幂运算或其与指定整数的模值

pow(2,3)    #8 2^3
pow(2,3,5)  #3 2^3%5
pow(2,3)%5  #3 2^3%5

round 对浮点数四舍五入求值

round(1.323423423,1) #1.3
round(1.323423423,5) #1.32342
round(1.65,1) #1.6
round(1.66,1) #1.7

sum 对元素类型是数值的可迭代对象中每个元素求和

sum((1,2,3,4))     #10
sum((1,2,3,4),-11) #-1

类型转换

bool

bool()    #False
bool(0)   #False
bool(1)   #True
bool(2)   #True

int

int()     #0
int(2.5)  #2

float

float()   #0.0
float(3)  #3.0
float('3')#3.0

complex

complex()       #0j
complex('1+2j') #(1+2j)
complex(1,2)    #(1+2j)

str

str()      #''
str(None)  #'None'
str('abc') #'abc'
str(123)   #'123'

bytearray 根据传入的参数创建一个新的字节数组：

bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

bytes 根据传入的参数创建一个新的字节数组：

bytes('中文','utf-8')

memoryview：根据传入的参数创建一个新的内存查看对象：

v = memoryview(b'abcefg') 
v[1] 
v[-1] 

ord：返回Unicode字符对应的整数:

ord('a') 

chr：返回整数所对应的Unicode字符:

chr(97) #参数类型为整数 

bin：将整数转换成2进制字符串

oct：将整数转化成8进制数字符串

hex：将整数转换成16进制字符串

bin(3)  

oct(3) 

hex(3) 

tuple：根据传入的参数创建一个新的元组:

tuple() #不传入参数，创建空元组 
tuple('121') #传入可迭代对象。使用其元素创建新的元组 

list：根据传入的参数创建一个新的列表:

list() # 不传入参数，创建空列表 
list('abcd') # 传入可迭代对象，使用其元素创建新的列表 

dict：根据传入的参数创建一个新的字典:

dict() # 不传入任何参数时，返回空字典。 
dict(a = 1,b = 2) # 可以传入键值对创建字典。 
dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。 
dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。 

set：根据传入的参数创建一个新的集合:

set() # 不传入参数，创建空集合 
a = set(range(10)) # 传入可迭代对象，创建集合 
a 

frozenset：根据传入的参数创建一个新的不可变集合:

a = frozenset(range(10)) 
a 

enumerate：根据可迭代对象创建枚举对象:

seasons = ['Spring', 'Summer', 'Fall', 'Winter'] 
list(enumerate(seasons)) 
list(enumerate(seasons, start=1)) #指定起始值 

range：根据传入的参数创建一个新的range对象:

a = range(10) 
b = range(1,10) 
c = range(1,10,3) 
a,b,c # 分别输出a,b,c 
list(a),list(b),list(c) # 分别输出a,b,c的元素 

iter：根据传入的参数创建一个新的可迭代对象:

a = iter('abcd') #字符串序列 
a 

next(a)

a = iter('abcd')
next(a) #'a'
next(a) #'b'
next(a) #'c'
next(a) #'d'

slice：根据传入的参数创建一个新的切片对象:

c1 = slice(5) # 定义c1 
c1 
c2 = slice(2,5) # 定义c2 
c2 
c3 = slice(1,10,3) # 定义c3 
c3 

super：根据传入的参数创建一个新的子类和父类关系的代理对象:

#定义父类A
class A(object):
    def __init__(self):
        print('A.__init__')

        
#定义子类B，继承A
class B(A):
    def __init__(self):
        print('B.__init__')
        super().__init__()


#super调用父类方法
b = B()
B.__init__
A.__init__

object：创建一个新的object对象:

a = object() 
a.name = 'kim' # 不能设置属性 

## 序列操作

all 判断可迭代对象是否都为True

all(())       #True
all({})       #True
all([])       #True
all([0])      #False
all([1,2])    #True
all([0,1,2])  #False

any 判断可迭代对象的元素是否有为True的元素

any(())       #False
any([])       #False
any({})       #False
any([0])      #False
any([1,2])    #True
any([0,1,2])  #True

filter 使用指定方法过滤可迭代对象的元素

a = list(range(1,10)) #定义序列
a

def if_odd(x)         #定义奇数判断函数
	return x%2 == 1


list(filter(if_odd,a))#筛选序列中的奇数

#[1, 3, 5, 7, 9]

map 使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象

a = map(ord,'abcd')
a
list(a)

#[97, 98, 99, 100]

next 返回可迭代对象中的下一个元素值

a = iter('abcd')
next(a)  #'a'
next(a)  #'b'
next(a)  #'c'
next(a)  #'d'

reversed 反转序列生成新的可迭代对象

a = reversed(range(10)) #传入range对象
a #类型变成迭代器
list(a)

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

sorted 对可迭代对象进行排序，返回一个新的列表

sorted(a,key = str.lower) # 转换成小写后再排序，'a’和’A’值一样，'b’和’B’值一样

a = ['a','b','c','B','A']
a
sorted(a)

#['A', 'B', 'a', 'b', 'c', 'd']

zip 聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器

x = [1,2,3]
y = [9,8,7,6]
list(zip(x,y))

#[(1,9), (2,8), (3,7)]

对象操作

help：返回对象的帮助信息：

help(str)  

](https://www.ipieuvre.com/doc/exper/34340a37-91ad-11e9-beeb-00215ec892f4/img/d2fba91d-dabf-48c2-bb12-d3c320fbd762.png)

注：如果要从help中退出，请按q键

dir：返回对象或者当前作用域内的属性列表：

import math 
math 
dir(math) 

id：返回对象的唯一标识符：

a = 'some text' 
id(a) 

hash：获取对象的哈希值：

hash('good good study') 

type：返回对象的类型，或者根据传入的参数创建一个新的类型：

type(1) # 返回对象的类型 

len：返回对象的长度：

len('abcd') # 字符串 
len([1,2,3,4]) # 列表 

ascii：返回对象的可打印表字符串表现方式：

ascii(1) 
ascii('&') 
ascii(9000000) 
ascii('中文') #非ascii字符 

format：格式化显示值：

"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序

"{0} {1}".format("hello", "world")  # 设置指定位置

"{1} {0} {1}".format("hello", "world")  # 设置指定位置
### 添加参数
print("urlname：{name}, addr {url}".format(name="zhangyu",url="www.ipieuvre.com"))
### 数字格式化
print("{:.2f}".format(3.1415926));

vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表：

class zhangyu: 
a = 1 

print(vars(zhangyu))